{-# 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.LookoutEquipment.CreateDataset
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a container for a collection of data being ingested for
-- analysis. The dataset contains the metadata describing where the data is
-- and what the data actually looks like. In other words, it contains the
-- location of the data source, the data schema, and other information. A
-- dataset also contains any tags associated with the ingested data.
module Amazonka.LookoutEquipment.CreateDataset
  ( -- * Creating a Request
    CreateDataset (..),
    newCreateDataset,

    -- * Request Lenses
    createDataset_datasetSchema,
    createDataset_serverSideKmsKeyId,
    createDataset_tags,
    createDataset_datasetName,
    createDataset_clientToken,

    -- * Destructuring the Response
    CreateDatasetResponse (..),
    newCreateDatasetResponse,

    -- * Response Lenses
    createDatasetResponse_datasetArn,
    createDatasetResponse_datasetName,
    createDatasetResponse_status,
    createDatasetResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateDataset' smart constructor.
data CreateDataset = CreateDataset'
  { -- | A JSON description of the data that is in each time series dataset,
    -- including names, column names, and data types.
    CreateDataset -> Maybe DatasetSchema
datasetSchema :: Prelude.Maybe DatasetSchema,
    -- | Provides the identifier of the KMS key used to encrypt dataset data by
    -- Amazon Lookout for Equipment.
    CreateDataset -> Maybe Text
serverSideKmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | Any tags associated with the ingested data described in the dataset.
    CreateDataset -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the dataset being created.
    CreateDataset -> Text
datasetName :: Prelude.Text,
    -- | A unique identifier for the request. If you do not set the client
    -- request token, Amazon Lookout for Equipment generates one.
    CreateDataset -> Text
clientToken :: Prelude.Text
  }
  deriving (CreateDataset -> CreateDataset -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDataset -> CreateDataset -> Bool
$c/= :: CreateDataset -> CreateDataset -> Bool
== :: CreateDataset -> CreateDataset -> Bool
$c== :: CreateDataset -> CreateDataset -> Bool
Prelude.Eq, ReadPrec [CreateDataset]
ReadPrec CreateDataset
Int -> ReadS CreateDataset
ReadS [CreateDataset]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDataset]
$creadListPrec :: ReadPrec [CreateDataset]
readPrec :: ReadPrec CreateDataset
$creadPrec :: ReadPrec CreateDataset
readList :: ReadS [CreateDataset]
$creadList :: ReadS [CreateDataset]
readsPrec :: Int -> ReadS CreateDataset
$creadsPrec :: Int -> ReadS CreateDataset
Prelude.Read, Int -> CreateDataset -> ShowS
[CreateDataset] -> ShowS
CreateDataset -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDataset] -> ShowS
$cshowList :: [CreateDataset] -> ShowS
show :: CreateDataset -> String
$cshow :: CreateDataset -> String
showsPrec :: Int -> CreateDataset -> ShowS
$cshowsPrec :: Int -> CreateDataset -> ShowS
Prelude.Show, forall x. Rep CreateDataset x -> CreateDataset
forall x. CreateDataset -> Rep CreateDataset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDataset x -> CreateDataset
$cfrom :: forall x. CreateDataset -> Rep CreateDataset x
Prelude.Generic)

-- |
-- Create a value of 'CreateDataset' 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:
--
-- 'datasetSchema', 'createDataset_datasetSchema' - A JSON description of the data that is in each time series dataset,
-- including names, column names, and data types.
--
-- 'serverSideKmsKeyId', 'createDataset_serverSideKmsKeyId' - Provides the identifier of the KMS key used to encrypt dataset data by
-- Amazon Lookout for Equipment.
--
-- 'tags', 'createDataset_tags' - Any tags associated with the ingested data described in the dataset.
--
-- 'datasetName', 'createDataset_datasetName' - The name of the dataset being created.
--
-- 'clientToken', 'createDataset_clientToken' - A unique identifier for the request. If you do not set the client
-- request token, Amazon Lookout for Equipment generates one.
newCreateDataset ::
  -- | 'datasetName'
  Prelude.Text ->
  -- | 'clientToken'
  Prelude.Text ->
  CreateDataset
newCreateDataset :: Text -> Text -> CreateDataset
newCreateDataset Text
pDatasetName_ Text
pClientToken_ =
  CreateDataset'
    { $sel:datasetSchema:CreateDataset' :: Maybe DatasetSchema
datasetSchema = forall a. Maybe a
Prelude.Nothing,
      $sel:serverSideKmsKeyId:CreateDataset' :: Maybe Text
serverSideKmsKeyId = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateDataset' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:datasetName:CreateDataset' :: Text
datasetName = Text
pDatasetName_,
      $sel:clientToken:CreateDataset' :: Text
clientToken = Text
pClientToken_
    }

-- | A JSON description of the data that is in each time series dataset,
-- including names, column names, and data types.
createDataset_datasetSchema :: Lens.Lens' CreateDataset (Prelude.Maybe DatasetSchema)
createDataset_datasetSchema :: Lens' CreateDataset (Maybe DatasetSchema)
createDataset_datasetSchema = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe DatasetSchema
datasetSchema :: Maybe DatasetSchema
$sel:datasetSchema:CreateDataset' :: CreateDataset -> Maybe DatasetSchema
datasetSchema} -> Maybe DatasetSchema
datasetSchema) (\s :: CreateDataset
s@CreateDataset' {} Maybe DatasetSchema
a -> CreateDataset
s {$sel:datasetSchema:CreateDataset' :: Maybe DatasetSchema
datasetSchema = Maybe DatasetSchema
a} :: CreateDataset)

-- | Provides the identifier of the KMS key used to encrypt dataset data by
-- Amazon Lookout for Equipment.
createDataset_serverSideKmsKeyId :: Lens.Lens' CreateDataset (Prelude.Maybe Prelude.Text)
createDataset_serverSideKmsKeyId :: Lens' CreateDataset (Maybe Text)
createDataset_serverSideKmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe Text
serverSideKmsKeyId :: Maybe Text
$sel:serverSideKmsKeyId:CreateDataset' :: CreateDataset -> Maybe Text
serverSideKmsKeyId} -> Maybe Text
serverSideKmsKeyId) (\s :: CreateDataset
s@CreateDataset' {} Maybe Text
a -> CreateDataset
s {$sel:serverSideKmsKeyId:CreateDataset' :: Maybe Text
serverSideKmsKeyId = Maybe Text
a} :: CreateDataset)

-- | Any tags associated with the ingested data described in the dataset.
createDataset_tags :: Lens.Lens' CreateDataset (Prelude.Maybe [Tag])
createDataset_tags :: Lens' CreateDataset (Maybe [Tag])
createDataset_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateDataset' :: CreateDataset -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateDataset
s@CreateDataset' {} Maybe [Tag]
a -> CreateDataset
s {$sel:tags:CreateDataset' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateDataset) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the dataset being created.
createDataset_datasetName :: Lens.Lens' CreateDataset Prelude.Text
createDataset_datasetName :: Lens' CreateDataset Text
createDataset_datasetName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Text
datasetName :: Text
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
datasetName} -> Text
datasetName) (\s :: CreateDataset
s@CreateDataset' {} Text
a -> CreateDataset
s {$sel:datasetName:CreateDataset' :: Text
datasetName = Text
a} :: CreateDataset)

-- | A unique identifier for the request. If you do not set the client
-- request token, Amazon Lookout for Equipment generates one.
createDataset_clientToken :: Lens.Lens' CreateDataset Prelude.Text
createDataset_clientToken :: Lens' CreateDataset Text
createDataset_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataset' {Text
clientToken :: Text
$sel:clientToken:CreateDataset' :: CreateDataset -> Text
clientToken} -> Text
clientToken) (\s :: CreateDataset
s@CreateDataset' {} Text
a -> CreateDataset
s {$sel:clientToken:CreateDataset' :: Text
clientToken = Text
a} :: CreateDataset)

instance Core.AWSRequest CreateDataset where
  type
    AWSResponse CreateDataset =
      CreateDatasetResponse
  request :: (Service -> Service) -> CreateDataset -> Request CreateDataset
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 CreateDataset
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateDataset)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe Text
-> Maybe DatasetStatus
-> Int
-> CreateDatasetResponse
CreateDatasetResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"DatasetArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"DatasetName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Status")
            forall (f :: * -> *) a b. Applicative f => 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 CreateDataset where
  hashWithSalt :: Int -> CreateDataset -> Int
hashWithSalt Int
_salt CreateDataset' {Maybe [Tag]
Maybe Text
Maybe DatasetSchema
Text
clientToken :: Text
datasetName :: Text
tags :: Maybe [Tag]
serverSideKmsKeyId :: Maybe Text
datasetSchema :: Maybe DatasetSchema
$sel:clientToken:CreateDataset' :: CreateDataset -> Text
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
$sel:tags:CreateDataset' :: CreateDataset -> Maybe [Tag]
$sel:serverSideKmsKeyId:CreateDataset' :: CreateDataset -> Maybe Text
$sel:datasetSchema:CreateDataset' :: CreateDataset -> Maybe DatasetSchema
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DatasetSchema
datasetSchema
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
serverSideKmsKeyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
datasetName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
clientToken

instance Prelude.NFData CreateDataset where
  rnf :: CreateDataset -> ()
rnf CreateDataset' {Maybe [Tag]
Maybe Text
Maybe DatasetSchema
Text
clientToken :: Text
datasetName :: Text
tags :: Maybe [Tag]
serverSideKmsKeyId :: Maybe Text
datasetSchema :: Maybe DatasetSchema
$sel:clientToken:CreateDataset' :: CreateDataset -> Text
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
$sel:tags:CreateDataset' :: CreateDataset -> Maybe [Tag]
$sel:serverSideKmsKeyId:CreateDataset' :: CreateDataset -> Maybe Text
$sel:datasetSchema:CreateDataset' :: CreateDataset -> Maybe DatasetSchema
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DatasetSchema
datasetSchema
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
serverSideKmsKeyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
datasetName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
clientToken

instance Data.ToHeaders CreateDataset where
  toHeaders :: CreateDataset -> 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
"AWSLookoutEquipmentFrontendService.CreateDataset" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateDataset where
  toJSON :: CreateDataset -> Value
toJSON CreateDataset' {Maybe [Tag]
Maybe Text
Maybe DatasetSchema
Text
clientToken :: Text
datasetName :: Text
tags :: Maybe [Tag]
serverSideKmsKeyId :: Maybe Text
datasetSchema :: Maybe DatasetSchema
$sel:clientToken:CreateDataset' :: CreateDataset -> Text
$sel:datasetName:CreateDataset' :: CreateDataset -> Text
$sel:tags:CreateDataset' :: CreateDataset -> Maybe [Tag]
$sel:serverSideKmsKeyId:CreateDataset' :: CreateDataset -> Maybe Text
$sel:datasetSchema:CreateDataset' :: CreateDataset -> Maybe DatasetSchema
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DatasetSchema" 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 DatasetSchema
datasetSchema,
            (Key
"ServerSideKmsKeyId" 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
serverSideKmsKeyId,
            (Key
"Tags" 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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"DatasetName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
datasetName),
            forall a. a -> Maybe a
Prelude.Just (Key
"ClientToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
clientToken)
          ]
      )

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

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

-- | /See:/ 'newCreateDatasetResponse' smart constructor.
data CreateDatasetResponse = CreateDatasetResponse'
  { -- | The Amazon Resource Name (ARN) of the dataset being created.
    CreateDatasetResponse -> Maybe Text
datasetArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the dataset being created.
    CreateDatasetResponse -> Maybe Text
datasetName :: Prelude.Maybe Prelude.Text,
    -- | Indicates the status of the @CreateDataset@ operation.
    CreateDatasetResponse -> Maybe DatasetStatus
status :: Prelude.Maybe DatasetStatus,
    -- | The response's http status code.
    CreateDatasetResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateDatasetResponse -> CreateDatasetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
$c/= :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
== :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
$c== :: CreateDatasetResponse -> CreateDatasetResponse -> Bool
Prelude.Eq, ReadPrec [CreateDatasetResponse]
ReadPrec CreateDatasetResponse
Int -> ReadS CreateDatasetResponse
ReadS [CreateDatasetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDatasetResponse]
$creadListPrec :: ReadPrec [CreateDatasetResponse]
readPrec :: ReadPrec CreateDatasetResponse
$creadPrec :: ReadPrec CreateDatasetResponse
readList :: ReadS [CreateDatasetResponse]
$creadList :: ReadS [CreateDatasetResponse]
readsPrec :: Int -> ReadS CreateDatasetResponse
$creadsPrec :: Int -> ReadS CreateDatasetResponse
Prelude.Read, Int -> CreateDatasetResponse -> ShowS
[CreateDatasetResponse] -> ShowS
CreateDatasetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDatasetResponse] -> ShowS
$cshowList :: [CreateDatasetResponse] -> ShowS
show :: CreateDatasetResponse -> String
$cshow :: CreateDatasetResponse -> String
showsPrec :: Int -> CreateDatasetResponse -> ShowS
$cshowsPrec :: Int -> CreateDatasetResponse -> ShowS
Prelude.Show, forall x. Rep CreateDatasetResponse x -> CreateDatasetResponse
forall x. CreateDatasetResponse -> Rep CreateDatasetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDatasetResponse x -> CreateDatasetResponse
$cfrom :: forall x. CreateDatasetResponse -> Rep CreateDatasetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDatasetResponse' 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:
--
-- 'datasetArn', 'createDatasetResponse_datasetArn' - The Amazon Resource Name (ARN) of the dataset being created.
--
-- 'datasetName', 'createDatasetResponse_datasetName' - The name of the dataset being created.
--
-- 'status', 'createDatasetResponse_status' - Indicates the status of the @CreateDataset@ operation.
--
-- 'httpStatus', 'createDatasetResponse_httpStatus' - The response's http status code.
newCreateDatasetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDatasetResponse
newCreateDatasetResponse :: Int -> CreateDatasetResponse
newCreateDatasetResponse Int
pHttpStatus_ =
  CreateDatasetResponse'
    { $sel:datasetArn:CreateDatasetResponse' :: Maybe Text
datasetArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:datasetName:CreateDatasetResponse' :: Maybe Text
datasetName = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateDatasetResponse' :: Maybe DatasetStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDatasetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the dataset being created.
createDatasetResponse_datasetArn :: Lens.Lens' CreateDatasetResponse (Prelude.Maybe Prelude.Text)
createDatasetResponse_datasetArn :: Lens' CreateDatasetResponse (Maybe Text)
createDatasetResponse_datasetArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetResponse' {Maybe Text
datasetArn :: Maybe Text
$sel:datasetArn:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe Text
datasetArn} -> Maybe Text
datasetArn) (\s :: CreateDatasetResponse
s@CreateDatasetResponse' {} Maybe Text
a -> CreateDatasetResponse
s {$sel:datasetArn:CreateDatasetResponse' :: Maybe Text
datasetArn = Maybe Text
a} :: CreateDatasetResponse)

-- | The name of the dataset being created.
createDatasetResponse_datasetName :: Lens.Lens' CreateDatasetResponse (Prelude.Maybe Prelude.Text)
createDatasetResponse_datasetName :: Lens' CreateDatasetResponse (Maybe Text)
createDatasetResponse_datasetName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetResponse' {Maybe Text
datasetName :: Maybe Text
$sel:datasetName:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe Text
datasetName} -> Maybe Text
datasetName) (\s :: CreateDatasetResponse
s@CreateDatasetResponse' {} Maybe Text
a -> CreateDatasetResponse
s {$sel:datasetName:CreateDatasetResponse' :: Maybe Text
datasetName = Maybe Text
a} :: CreateDatasetResponse)

-- | Indicates the status of the @CreateDataset@ operation.
createDatasetResponse_status :: Lens.Lens' CreateDatasetResponse (Prelude.Maybe DatasetStatus)
createDatasetResponse_status :: Lens' CreateDatasetResponse (Maybe DatasetStatus)
createDatasetResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetResponse' {Maybe DatasetStatus
status :: Maybe DatasetStatus
$sel:status:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe DatasetStatus
status} -> Maybe DatasetStatus
status) (\s :: CreateDatasetResponse
s@CreateDatasetResponse' {} Maybe DatasetStatus
a -> CreateDatasetResponse
s {$sel:status:CreateDatasetResponse' :: Maybe DatasetStatus
status = Maybe DatasetStatus
a} :: CreateDatasetResponse)

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

instance Prelude.NFData CreateDatasetResponse where
  rnf :: CreateDatasetResponse -> ()
rnf CreateDatasetResponse' {Int
Maybe Text
Maybe DatasetStatus
httpStatus :: Int
status :: Maybe DatasetStatus
datasetName :: Maybe Text
datasetArn :: Maybe Text
$sel:httpStatus:CreateDatasetResponse' :: CreateDatasetResponse -> Int
$sel:status:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe DatasetStatus
$sel:datasetName:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe Text
$sel:datasetArn:CreateDatasetResponse' :: CreateDatasetResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
datasetArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
datasetName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DatasetStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus