{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.SSM.CreateResourceDataSync
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- A resource data sync helps you view data from multiple sources in a
-- single location. Amazon Web Services Systems Manager offers two types of
-- resource data sync: @SyncToDestination@ and @SyncFromSource@.
--
-- You can configure Systems Manager Inventory to use the
-- @SyncToDestination@ type to synchronize Inventory data from multiple
-- Amazon Web Services Regions to a single Amazon Simple Storage Service
-- (Amazon S3) bucket. For more information, see
-- <https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-inventory-datasync.html Configuring resource data sync for Inventory>
-- in the /Amazon Web Services Systems Manager User Guide/.
--
-- You can configure Systems Manager Explorer to use the @SyncFromSource@
-- type to synchronize operational work items (OpsItems) and operational
-- data (OpsData) from multiple Amazon Web Services Regions to a single
-- Amazon S3 bucket. This type can synchronize OpsItems and OpsData from
-- multiple Amazon Web Services accounts and Amazon Web Services Regions or
-- @EntireOrganization@ by using Organizations. For more information, see
-- <https://docs.aws.amazon.com/systems-manager/latest/userguide/Explorer-resource-data-sync.html Setting up Systems Manager Explorer to display data from multiple accounts and Regions>
-- in the /Amazon Web Services Systems Manager User Guide/.
--
-- A resource data sync is an asynchronous operation that returns
-- immediately. After a successful initial sync is completed, the system
-- continuously syncs data. To check the status of a sync, use the
-- ListResourceDataSync.
--
-- By default, data isn\'t encrypted in Amazon S3. We strongly recommend
-- that you enable encryption in Amazon S3 to ensure secure data storage.
-- We also recommend that you secure access to the Amazon S3 bucket by
-- creating a restrictive bucket policy.
module Amazonka.SSM.CreateResourceDataSync
  ( -- * Creating a Request
    CreateResourceDataSync (..),
    newCreateResourceDataSync,

    -- * Request Lenses
    createResourceDataSync_s3Destination,
    createResourceDataSync_syncSource,
    createResourceDataSync_syncType,
    createResourceDataSync_syncName,

    -- * Destructuring the Response
    CreateResourceDataSyncResponse (..),
    newCreateResourceDataSyncResponse,

    -- * Response Lenses
    createResourceDataSyncResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SSM.Types

-- | /See:/ 'newCreateResourceDataSync' smart constructor.
data CreateResourceDataSync = CreateResourceDataSync'
  { -- | Amazon S3 configuration details for the sync. This parameter is required
    -- if the @SyncType@ value is SyncToDestination.
    CreateResourceDataSync -> Maybe ResourceDataSyncS3Destination
s3Destination :: Prelude.Maybe ResourceDataSyncS3Destination,
    -- | Specify information about the data sources to synchronize. This
    -- parameter is required if the @SyncType@ value is SyncFromSource.
    CreateResourceDataSync -> Maybe ResourceDataSyncSource
syncSource :: Prelude.Maybe ResourceDataSyncSource,
    -- | Specify @SyncToDestination@ to create a resource data sync that
    -- synchronizes data to an S3 bucket for Inventory. If you specify
    -- @SyncToDestination@, you must provide a value for @S3Destination@.
    -- Specify @SyncFromSource@ to synchronize data from a single account and
    -- multiple Regions, or multiple Amazon Web Services accounts and Amazon
    -- Web Services Regions, as listed in Organizations for Explorer. If you
    -- specify @SyncFromSource@, you must provide a value for @SyncSource@. The
    -- default value is @SyncToDestination@.
    CreateResourceDataSync -> Maybe Text
syncType :: Prelude.Maybe Prelude.Text,
    -- | A name for the configuration.
    CreateResourceDataSync -> Text
syncName :: Prelude.Text
  }
  deriving (CreateResourceDataSync -> CreateResourceDataSync -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResourceDataSync -> CreateResourceDataSync -> Bool
$c/= :: CreateResourceDataSync -> CreateResourceDataSync -> Bool
== :: CreateResourceDataSync -> CreateResourceDataSync -> Bool
$c== :: CreateResourceDataSync -> CreateResourceDataSync -> Bool
Prelude.Eq, ReadPrec [CreateResourceDataSync]
ReadPrec CreateResourceDataSync
Int -> ReadS CreateResourceDataSync
ReadS [CreateResourceDataSync]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResourceDataSync]
$creadListPrec :: ReadPrec [CreateResourceDataSync]
readPrec :: ReadPrec CreateResourceDataSync
$creadPrec :: ReadPrec CreateResourceDataSync
readList :: ReadS [CreateResourceDataSync]
$creadList :: ReadS [CreateResourceDataSync]
readsPrec :: Int -> ReadS CreateResourceDataSync
$creadsPrec :: Int -> ReadS CreateResourceDataSync
Prelude.Read, Int -> CreateResourceDataSync -> ShowS
[CreateResourceDataSync] -> ShowS
CreateResourceDataSync -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResourceDataSync] -> ShowS
$cshowList :: [CreateResourceDataSync] -> ShowS
show :: CreateResourceDataSync -> String
$cshow :: CreateResourceDataSync -> String
showsPrec :: Int -> CreateResourceDataSync -> ShowS
$cshowsPrec :: Int -> CreateResourceDataSync -> ShowS
Prelude.Show, forall x. Rep CreateResourceDataSync x -> CreateResourceDataSync
forall x. CreateResourceDataSync -> Rep CreateResourceDataSync x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateResourceDataSync x -> CreateResourceDataSync
$cfrom :: forall x. CreateResourceDataSync -> Rep CreateResourceDataSync x
Prelude.Generic)

-- |
-- Create a value of 'CreateResourceDataSync' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 's3Destination', 'createResourceDataSync_s3Destination' - Amazon S3 configuration details for the sync. This parameter is required
-- if the @SyncType@ value is SyncToDestination.
--
-- 'syncSource', 'createResourceDataSync_syncSource' - Specify information about the data sources to synchronize. This
-- parameter is required if the @SyncType@ value is SyncFromSource.
--
-- 'syncType', 'createResourceDataSync_syncType' - Specify @SyncToDestination@ to create a resource data sync that
-- synchronizes data to an S3 bucket for Inventory. If you specify
-- @SyncToDestination@, you must provide a value for @S3Destination@.
-- Specify @SyncFromSource@ to synchronize data from a single account and
-- multiple Regions, or multiple Amazon Web Services accounts and Amazon
-- Web Services Regions, as listed in Organizations for Explorer. If you
-- specify @SyncFromSource@, you must provide a value for @SyncSource@. The
-- default value is @SyncToDestination@.
--
-- 'syncName', 'createResourceDataSync_syncName' - A name for the configuration.
newCreateResourceDataSync ::
  -- | 'syncName'
  Prelude.Text ->
  CreateResourceDataSync
newCreateResourceDataSync :: Text -> CreateResourceDataSync
newCreateResourceDataSync Text
pSyncName_ =
  CreateResourceDataSync'
    { $sel:s3Destination:CreateResourceDataSync' :: Maybe ResourceDataSyncS3Destination
s3Destination =
        forall a. Maybe a
Prelude.Nothing,
      $sel:syncSource:CreateResourceDataSync' :: Maybe ResourceDataSyncSource
syncSource = forall a. Maybe a
Prelude.Nothing,
      $sel:syncType:CreateResourceDataSync' :: Maybe Text
syncType = forall a. Maybe a
Prelude.Nothing,
      $sel:syncName:CreateResourceDataSync' :: Text
syncName = Text
pSyncName_
    }

-- | Amazon S3 configuration details for the sync. This parameter is required
-- if the @SyncType@ value is SyncToDestination.
createResourceDataSync_s3Destination :: Lens.Lens' CreateResourceDataSync (Prelude.Maybe ResourceDataSyncS3Destination)
createResourceDataSync_s3Destination :: Lens' CreateResourceDataSync (Maybe ResourceDataSyncS3Destination)
createResourceDataSync_s3Destination = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourceDataSync' {Maybe ResourceDataSyncS3Destination
s3Destination :: Maybe ResourceDataSyncS3Destination
$sel:s3Destination:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncS3Destination
s3Destination} -> Maybe ResourceDataSyncS3Destination
s3Destination) (\s :: CreateResourceDataSync
s@CreateResourceDataSync' {} Maybe ResourceDataSyncS3Destination
a -> CreateResourceDataSync
s {$sel:s3Destination:CreateResourceDataSync' :: Maybe ResourceDataSyncS3Destination
s3Destination = Maybe ResourceDataSyncS3Destination
a} :: CreateResourceDataSync)

-- | Specify information about the data sources to synchronize. This
-- parameter is required if the @SyncType@ value is SyncFromSource.
createResourceDataSync_syncSource :: Lens.Lens' CreateResourceDataSync (Prelude.Maybe ResourceDataSyncSource)
createResourceDataSync_syncSource :: Lens' CreateResourceDataSync (Maybe ResourceDataSyncSource)
createResourceDataSync_syncSource = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourceDataSync' {Maybe ResourceDataSyncSource
syncSource :: Maybe ResourceDataSyncSource
$sel:syncSource:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncSource
syncSource} -> Maybe ResourceDataSyncSource
syncSource) (\s :: CreateResourceDataSync
s@CreateResourceDataSync' {} Maybe ResourceDataSyncSource
a -> CreateResourceDataSync
s {$sel:syncSource:CreateResourceDataSync' :: Maybe ResourceDataSyncSource
syncSource = Maybe ResourceDataSyncSource
a} :: CreateResourceDataSync)

-- | Specify @SyncToDestination@ to create a resource data sync that
-- synchronizes data to an S3 bucket for Inventory. If you specify
-- @SyncToDestination@, you must provide a value for @S3Destination@.
-- Specify @SyncFromSource@ to synchronize data from a single account and
-- multiple Regions, or multiple Amazon Web Services accounts and Amazon
-- Web Services Regions, as listed in Organizations for Explorer. If you
-- specify @SyncFromSource@, you must provide a value for @SyncSource@. The
-- default value is @SyncToDestination@.
createResourceDataSync_syncType :: Lens.Lens' CreateResourceDataSync (Prelude.Maybe Prelude.Text)
createResourceDataSync_syncType :: Lens' CreateResourceDataSync (Maybe Text)
createResourceDataSync_syncType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourceDataSync' {Maybe Text
syncType :: Maybe Text
$sel:syncType:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe Text
syncType} -> Maybe Text
syncType) (\s :: CreateResourceDataSync
s@CreateResourceDataSync' {} Maybe Text
a -> CreateResourceDataSync
s {$sel:syncType:CreateResourceDataSync' :: Maybe Text
syncType = Maybe Text
a} :: CreateResourceDataSync)

-- | A name for the configuration.
createResourceDataSync_syncName :: Lens.Lens' CreateResourceDataSync Prelude.Text
createResourceDataSync_syncName :: Lens' CreateResourceDataSync Text
createResourceDataSync_syncName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourceDataSync' {Text
syncName :: Text
$sel:syncName:CreateResourceDataSync' :: CreateResourceDataSync -> Text
syncName} -> Text
syncName) (\s :: CreateResourceDataSync
s@CreateResourceDataSync' {} Text
a -> CreateResourceDataSync
s {$sel:syncName:CreateResourceDataSync' :: Text
syncName = Text
a} :: CreateResourceDataSync)

instance Core.AWSRequest CreateResourceDataSync where
  type
    AWSResponse CreateResourceDataSync =
      CreateResourceDataSyncResponse
  request :: (Service -> Service)
-> CreateResourceDataSync -> Request CreateResourceDataSync
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateResourceDataSync
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateResourceDataSync)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> CreateResourceDataSyncResponse
CreateResourceDataSyncResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateResourceDataSync where
  hashWithSalt :: Int -> CreateResourceDataSync -> Int
hashWithSalt Int
_salt CreateResourceDataSync' {Maybe Text
Maybe ResourceDataSyncS3Destination
Maybe ResourceDataSyncSource
Text
syncName :: Text
syncType :: Maybe Text
syncSource :: Maybe ResourceDataSyncSource
s3Destination :: Maybe ResourceDataSyncS3Destination
$sel:syncName:CreateResourceDataSync' :: CreateResourceDataSync -> Text
$sel:syncType:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe Text
$sel:syncSource:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncSource
$sel:s3Destination:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncS3Destination
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResourceDataSyncS3Destination
s3Destination
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResourceDataSyncSource
syncSource
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
syncType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
syncName

instance Prelude.NFData CreateResourceDataSync where
  rnf :: CreateResourceDataSync -> ()
rnf CreateResourceDataSync' {Maybe Text
Maybe ResourceDataSyncS3Destination
Maybe ResourceDataSyncSource
Text
syncName :: Text
syncType :: Maybe Text
syncSource :: Maybe ResourceDataSyncSource
s3Destination :: Maybe ResourceDataSyncS3Destination
$sel:syncName:CreateResourceDataSync' :: CreateResourceDataSync -> Text
$sel:syncType:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe Text
$sel:syncSource:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncSource
$sel:s3Destination:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncS3Destination
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceDataSyncS3Destination
s3Destination
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceDataSyncSource
syncSource
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
syncType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
syncName

instance Data.ToHeaders CreateResourceDataSync where
  toHeaders :: CreateResourceDataSync -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AmazonSSM.CreateResourceDataSync" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateResourceDataSync where
  toJSON :: CreateResourceDataSync -> Value
toJSON CreateResourceDataSync' {Maybe Text
Maybe ResourceDataSyncS3Destination
Maybe ResourceDataSyncSource
Text
syncName :: Text
syncType :: Maybe Text
syncSource :: Maybe ResourceDataSyncSource
s3Destination :: Maybe ResourceDataSyncS3Destination
$sel:syncName:CreateResourceDataSync' :: CreateResourceDataSync -> Text
$sel:syncType:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe Text
$sel:syncSource:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncSource
$sel:s3Destination:CreateResourceDataSync' :: CreateResourceDataSync -> Maybe ResourceDataSyncS3Destination
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"S3Destination" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ResourceDataSyncS3Destination
s3Destination,
            (Key
"SyncSource" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ResourceDataSyncSource
syncSource,
            (Key
"SyncType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
syncType,
            forall a. a -> Maybe a
Prelude.Just (Key
"SyncName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
syncName)
          ]
      )

instance Data.ToPath CreateResourceDataSync where
  toPath :: CreateResourceDataSync -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery CreateResourceDataSync where
  toQuery :: CreateResourceDataSync -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCreateResourceDataSyncResponse' smart constructor.
data CreateResourceDataSyncResponse = CreateResourceDataSyncResponse'
  { -- | The response's http status code.
    CreateResourceDataSyncResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateResourceDataSyncResponse
-> CreateResourceDataSyncResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResourceDataSyncResponse
-> CreateResourceDataSyncResponse -> Bool
$c/= :: CreateResourceDataSyncResponse
-> CreateResourceDataSyncResponse -> Bool
== :: CreateResourceDataSyncResponse
-> CreateResourceDataSyncResponse -> Bool
$c== :: CreateResourceDataSyncResponse
-> CreateResourceDataSyncResponse -> Bool
Prelude.Eq, ReadPrec [CreateResourceDataSyncResponse]
ReadPrec CreateResourceDataSyncResponse
Int -> ReadS CreateResourceDataSyncResponse
ReadS [CreateResourceDataSyncResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResourceDataSyncResponse]
$creadListPrec :: ReadPrec [CreateResourceDataSyncResponse]
readPrec :: ReadPrec CreateResourceDataSyncResponse
$creadPrec :: ReadPrec CreateResourceDataSyncResponse
readList :: ReadS [CreateResourceDataSyncResponse]
$creadList :: ReadS [CreateResourceDataSyncResponse]
readsPrec :: Int -> ReadS CreateResourceDataSyncResponse
$creadsPrec :: Int -> ReadS CreateResourceDataSyncResponse
Prelude.Read, Int -> CreateResourceDataSyncResponse -> ShowS
[CreateResourceDataSyncResponse] -> ShowS
CreateResourceDataSyncResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResourceDataSyncResponse] -> ShowS
$cshowList :: [CreateResourceDataSyncResponse] -> ShowS
show :: CreateResourceDataSyncResponse -> String
$cshow :: CreateResourceDataSyncResponse -> String
showsPrec :: Int -> CreateResourceDataSyncResponse -> ShowS
$cshowsPrec :: Int -> CreateResourceDataSyncResponse -> ShowS
Prelude.Show, forall x.
Rep CreateResourceDataSyncResponse x
-> CreateResourceDataSyncResponse
forall x.
CreateResourceDataSyncResponse
-> Rep CreateResourceDataSyncResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateResourceDataSyncResponse x
-> CreateResourceDataSyncResponse
$cfrom :: forall x.
CreateResourceDataSyncResponse
-> Rep CreateResourceDataSyncResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateResourceDataSyncResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'httpStatus', 'createResourceDataSyncResponse_httpStatus' - The response's http status code.
newCreateResourceDataSyncResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateResourceDataSyncResponse
newCreateResourceDataSyncResponse :: Int -> CreateResourceDataSyncResponse
newCreateResourceDataSyncResponse Int
pHttpStatus_ =
  CreateResourceDataSyncResponse'
    { $sel:httpStatus:CreateResourceDataSyncResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

-- | The response's http status code.
createResourceDataSyncResponse_httpStatus :: Lens.Lens' CreateResourceDataSyncResponse Prelude.Int
createResourceDataSyncResponse_httpStatus :: Lens' CreateResourceDataSyncResponse Int
createResourceDataSyncResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResourceDataSyncResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateResourceDataSyncResponse' :: CreateResourceDataSyncResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateResourceDataSyncResponse
s@CreateResourceDataSyncResponse' {} Int
a -> CreateResourceDataSyncResponse
s {$sel:httpStatus:CreateResourceDataSyncResponse' :: Int
httpStatus = Int
a} :: CreateResourceDataSyncResponse)

instance
  Prelude.NFData
    CreateResourceDataSyncResponse
  where
  rnf :: CreateResourceDataSyncResponse -> ()
rnf CreateResourceDataSyncResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateResourceDataSyncResponse' :: CreateResourceDataSyncResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus