{-# 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.DataExchange.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)
--
-- This operation creates a data set.
module Amazonka.DataExchange.CreateDataSet
  ( -- * Creating a Request
    CreateDataSet (..),
    newCreateDataSet,

    -- * Request Lenses
    createDataSet_tags,
    createDataSet_assetType,
    createDataSet_description,
    createDataSet_name,

    -- * Destructuring the Response
    CreateDataSetResponse (..),
    newCreateDataSetResponse,

    -- * Response Lenses
    createDataSetResponse_arn,
    createDataSetResponse_assetType,
    createDataSetResponse_createdAt,
    createDataSetResponse_description,
    createDataSetResponse_id,
    createDataSetResponse_name,
    createDataSetResponse_origin,
    createDataSetResponse_originDetails,
    createDataSetResponse_sourceId,
    createDataSetResponse_tags,
    createDataSetResponse_updatedAt,
    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.DataExchange.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 data set tag is an optional label that you can assign to a data set
    -- when you create it. Each tag consists of a key and an optional value,
    -- both of which you define. When you use tagging, you can also use
    -- tag-based access control in IAM policies to control access to these data
    -- sets and revisions.
    CreateDataSet -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The type of asset that is added to a data set.
    CreateDataSet -> AssetType
assetType :: AssetType,
    -- | A description for the data set. This value can be up to 16,348
    -- characters long.
    CreateDataSet -> Text
description :: Prelude.Text,
    -- | The name of the data set.
    CreateDataSet -> Text
name :: 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:
--
-- 'tags', 'createDataSet_tags' - A data set tag is an optional label that you can assign to a data set
-- when you create it. Each tag consists of a key and an optional value,
-- both of which you define. When you use tagging, you can also use
-- tag-based access control in IAM policies to control access to these data
-- sets and revisions.
--
-- 'assetType', 'createDataSet_assetType' - The type of asset that is added to a data set.
--
-- 'description', 'createDataSet_description' - A description for the data set. This value can be up to 16,348
-- characters long.
--
-- 'name', 'createDataSet_name' - The name of the data set.
newCreateDataSet ::
  -- | 'assetType'
  AssetType ->
  -- | 'description'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  CreateDataSet
newCreateDataSet :: AssetType -> Text -> Text -> CreateDataSet
newCreateDataSet AssetType
pAssetType_ Text
pDescription_ Text
pName_ =
  CreateDataSet'
    { $sel:tags:CreateDataSet' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:assetType:CreateDataSet' :: AssetType
assetType = AssetType
pAssetType_,
      $sel:description:CreateDataSet' :: Text
description = Text
pDescription_,
      $sel:name:CreateDataSet' :: Text
name = Text
pName_
    }

-- | A data set tag is an optional label that you can assign to a data set
-- when you create it. Each tag consists of a key and an optional value,
-- both of which you define. When you use tagging, you can also use
-- tag-based access control in IAM policies to control access to these data
-- sets and revisions.
createDataSet_tags :: Lens.Lens' CreateDataSet (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createDataSet_tags :: Lens' CreateDataSet (Maybe (HashMap Text Text))
createDataSet_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSet' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateDataSet' :: CreateDataSet -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateDataSet
s@CreateDataSet' {} Maybe (HashMap Text Text)
a -> CreateDataSet
s {$sel:tags:CreateDataSet' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
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 type of asset that is added to a data set.
createDataSet_assetType :: Lens.Lens' CreateDataSet AssetType
createDataSet_assetType :: Lens' CreateDataSet AssetType
createDataSet_assetType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSet' {AssetType
assetType :: AssetType
$sel:assetType:CreateDataSet' :: CreateDataSet -> AssetType
assetType} -> AssetType
assetType) (\s :: CreateDataSet
s@CreateDataSet' {} AssetType
a -> CreateDataSet
s {$sel:assetType:CreateDataSet' :: AssetType
assetType = AssetType
a} :: CreateDataSet)

-- | A description for the data set. This value can be up to 16,348
-- characters long.
createDataSet_description :: Lens.Lens' CreateDataSet Prelude.Text
createDataSet_description :: Lens' CreateDataSet Text
createDataSet_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSet' {Text
description :: Text
$sel:description:CreateDataSet' :: CreateDataSet -> Text
description} -> Text
description) (\s :: CreateDataSet
s@CreateDataSet' {} Text
a -> CreateDataSet
s {$sel:description:CreateDataSet' :: Text
description = Text
a} :: CreateDataSet)

-- | The name of the data set.
createDataSet_name :: Lens.Lens' CreateDataSet Prelude.Text
createDataSet_name :: Lens' CreateDataSet Text
createDataSet_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSet' {Text
name :: Text
$sel:name:CreateDataSet' :: CreateDataSet -> Text
name} -> Text
name) (\s :: CreateDataSet
s@CreateDataSet' {} Text
a -> CreateDataSet
s {$sel:name:CreateDataSet' :: Text
name = 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 AssetType
-> Maybe ISO8601
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Origin
-> Maybe OriginDetails
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe ISO8601
-> 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
"Arn")
            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
"AssetType")
            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
"CreatedAt")
            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
"Description")
            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
"Id")
            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
"Name")
            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
"Origin")
            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
"OriginDetails")
            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
"SourceId")
            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
"Tags" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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
"UpdatedAt")
            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 (HashMap Text Text)
Text
AssetType
name :: Text
description :: Text
assetType :: AssetType
tags :: Maybe (HashMap Text Text)
$sel:name:CreateDataSet' :: CreateDataSet -> Text
$sel:description:CreateDataSet' :: CreateDataSet -> Text
$sel:assetType:CreateDataSet' :: CreateDataSet -> AssetType
$sel:tags:CreateDataSet' :: CreateDataSet -> Maybe (HashMap Text Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` AssetType
assetType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateDataSet where
  rnf :: CreateDataSet -> ()
rnf CreateDataSet' {Maybe (HashMap Text Text)
Text
AssetType
name :: Text
description :: Text
assetType :: AssetType
tags :: Maybe (HashMap Text Text)
$sel:name:CreateDataSet' :: CreateDataSet -> Text
$sel:description:CreateDataSet' :: CreateDataSet -> Text
$sel:assetType:CreateDataSet' :: CreateDataSet -> AssetType
$sel:tags:CreateDataSet' :: CreateDataSet -> Maybe (HashMap Text Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf AssetType
assetType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name

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
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateDataSet where
  toJSON :: CreateDataSet -> Value
toJSON CreateDataSet' {Maybe (HashMap Text Text)
Text
AssetType
name :: Text
description :: Text
assetType :: AssetType
tags :: Maybe (HashMap Text Text)
$sel:name:CreateDataSet' :: CreateDataSet -> Text
$sel:description:CreateDataSet' :: CreateDataSet -> Text
$sel:assetType:CreateDataSet' :: CreateDataSet -> AssetType
$sel:tags:CreateDataSet' :: CreateDataSet -> Maybe (HashMap Text Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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 (HashMap Text Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"AssetType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= AssetType
assetType),
            forall a. a -> Maybe a
Prelude.Just (Key
"Description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
description),
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

instance Data.ToPath CreateDataSet where
  toPath :: CreateDataSet -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/v1/data-sets"

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 ARN for the data set.
    CreateDataSetResponse -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | The type of asset that is added to a data set.
    CreateDataSetResponse -> Maybe AssetType
assetType :: Prelude.Maybe AssetType,
    -- | The date and time that the data set was created, in ISO 8601 format.
    CreateDataSetResponse -> Maybe ISO8601
createdAt :: Prelude.Maybe Data.ISO8601,
    -- | The description for the data set.
    CreateDataSetResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The unique identifier for the data set.
    CreateDataSetResponse -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The name of the data set.
    CreateDataSetResponse -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | A property that defines the data set as OWNED by the account (for
    -- providers) or ENTITLED to the account (for subscribers).
    CreateDataSetResponse -> Maybe Origin
origin :: Prelude.Maybe Origin,
    -- | If the origin of this data set is ENTITLED, includes the details for the
    -- product on AWS Marketplace.
    CreateDataSetResponse -> Maybe OriginDetails
originDetails :: Prelude.Maybe OriginDetails,
    -- | The data set ID of the owned data set corresponding to the entitled data
    -- set being viewed. This parameter is returned when a data set owner is
    -- viewing the entitled copy of its owned data set.
    CreateDataSetResponse -> Maybe Text
sourceId :: Prelude.Maybe Prelude.Text,
    -- | The tags for the data set.
    CreateDataSetResponse -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The date and time that the data set was last updated, in ISO 8601
    -- format.
    CreateDataSetResponse -> Maybe ISO8601
updatedAt :: Prelude.Maybe Data.ISO8601,
    -- | 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:
--
-- 'arn', 'createDataSetResponse_arn' - The ARN for the data set.
--
-- 'assetType', 'createDataSetResponse_assetType' - The type of asset that is added to a data set.
--
-- 'createdAt', 'createDataSetResponse_createdAt' - The date and time that the data set was created, in ISO 8601 format.
--
-- 'description', 'createDataSetResponse_description' - The description for the data set.
--
-- 'id', 'createDataSetResponse_id' - The unique identifier for the data set.
--
-- 'name', 'createDataSetResponse_name' - The name of the data set.
--
-- 'origin', 'createDataSetResponse_origin' - A property that defines the data set as OWNED by the account (for
-- providers) or ENTITLED to the account (for subscribers).
--
-- 'originDetails', 'createDataSetResponse_originDetails' - If the origin of this data set is ENTITLED, includes the details for the
-- product on AWS Marketplace.
--
-- 'sourceId', 'createDataSetResponse_sourceId' - The data set ID of the owned data set corresponding to the entitled data
-- set being viewed. This parameter is returned when a data set owner is
-- viewing the entitled copy of its owned data set.
--
-- 'tags', 'createDataSetResponse_tags' - The tags for the data set.
--
-- 'updatedAt', 'createDataSetResponse_updatedAt' - The date and time that the data set was last updated, in ISO 8601
-- format.
--
-- 'httpStatus', 'createDataSetResponse_httpStatus' - The response's http status code.
newCreateDataSetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDataSetResponse
newCreateDataSetResponse :: Int -> CreateDataSetResponse
newCreateDataSetResponse Int
pHttpStatus_ =
  CreateDataSetResponse'
    { $sel:arn:CreateDataSetResponse' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:assetType:CreateDataSetResponse' :: Maybe AssetType
assetType = forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:CreateDataSetResponse' :: Maybe ISO8601
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateDataSetResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:id:CreateDataSetResponse' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateDataSetResponse' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:origin:CreateDataSetResponse' :: Maybe Origin
origin = forall a. Maybe a
Prelude.Nothing,
      $sel:originDetails:CreateDataSetResponse' :: Maybe OriginDetails
originDetails = forall a. Maybe a
Prelude.Nothing,
      $sel:sourceId:CreateDataSetResponse' :: Maybe Text
sourceId = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateDataSetResponse' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:updatedAt:CreateDataSetResponse' :: Maybe ISO8601
updatedAt = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDataSetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN for the data set.
createDataSetResponse_arn :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.Text)
createDataSetResponse_arn :: Lens' CreateDataSetResponse (Maybe Text)
createDataSetResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe Text
arn :: Maybe Text
$sel:arn:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
arn} -> Maybe Text
arn) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe Text
a -> CreateDataSetResponse
s {$sel:arn:CreateDataSetResponse' :: Maybe Text
arn = Maybe Text
a} :: CreateDataSetResponse)

-- | The type of asset that is added to a data set.
createDataSetResponse_assetType :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe AssetType)
createDataSetResponse_assetType :: Lens' CreateDataSetResponse (Maybe AssetType)
createDataSetResponse_assetType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe AssetType
assetType :: Maybe AssetType
$sel:assetType:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe AssetType
assetType} -> Maybe AssetType
assetType) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe AssetType
a -> CreateDataSetResponse
s {$sel:assetType:CreateDataSetResponse' :: Maybe AssetType
assetType = Maybe AssetType
a} :: CreateDataSetResponse)

-- | The date and time that the data set was created, in ISO 8601 format.
createDataSetResponse_createdAt :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.UTCTime)
createDataSetResponse_createdAt :: Lens' CreateDataSetResponse (Maybe UTCTime)
createDataSetResponse_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe ISO8601
createdAt :: Maybe ISO8601
$sel:createdAt:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe ISO8601
createdAt} -> Maybe ISO8601
createdAt) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe ISO8601
a -> CreateDataSetResponse
s {$sel:createdAt:CreateDataSetResponse' :: Maybe ISO8601
createdAt = Maybe ISO8601
a} :: CreateDataSetResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The description for the data set.
createDataSetResponse_description :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.Text)
createDataSetResponse_description :: Lens' CreateDataSetResponse (Maybe Text)
createDataSetResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe Text
description :: Maybe Text
$sel:description:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe Text
a -> CreateDataSetResponse
s {$sel:description:CreateDataSetResponse' :: Maybe Text
description = Maybe Text
a} :: CreateDataSetResponse)

-- | The unique identifier for the data set.
createDataSetResponse_id :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.Text)
createDataSetResponse_id :: Lens' CreateDataSetResponse (Maybe Text)
createDataSetResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe Text
id :: Maybe Text
$sel:id:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
id} -> Maybe Text
id) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe Text
a -> CreateDataSetResponse
s {$sel:id:CreateDataSetResponse' :: Maybe Text
id = Maybe Text
a} :: CreateDataSetResponse)

-- | The name of the data set.
createDataSetResponse_name :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.Text)
createDataSetResponse_name :: Lens' CreateDataSetResponse (Maybe Text)
createDataSetResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe Text
name :: Maybe Text
$sel:name:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe Text
a -> CreateDataSetResponse
s {$sel:name:CreateDataSetResponse' :: Maybe Text
name = Maybe Text
a} :: CreateDataSetResponse)

-- | A property that defines the data set as OWNED by the account (for
-- providers) or ENTITLED to the account (for subscribers).
createDataSetResponse_origin :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Origin)
createDataSetResponse_origin :: Lens' CreateDataSetResponse (Maybe Origin)
createDataSetResponse_origin = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe Origin
origin :: Maybe Origin
$sel:origin:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Origin
origin} -> Maybe Origin
origin) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe Origin
a -> CreateDataSetResponse
s {$sel:origin:CreateDataSetResponse' :: Maybe Origin
origin = Maybe Origin
a} :: CreateDataSetResponse)

-- | If the origin of this data set is ENTITLED, includes the details for the
-- product on AWS Marketplace.
createDataSetResponse_originDetails :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe OriginDetails)
createDataSetResponse_originDetails :: Lens' CreateDataSetResponse (Maybe OriginDetails)
createDataSetResponse_originDetails = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe OriginDetails
originDetails :: Maybe OriginDetails
$sel:originDetails:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe OriginDetails
originDetails} -> Maybe OriginDetails
originDetails) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe OriginDetails
a -> CreateDataSetResponse
s {$sel:originDetails:CreateDataSetResponse' :: Maybe OriginDetails
originDetails = Maybe OriginDetails
a} :: CreateDataSetResponse)

-- | The data set ID of the owned data set corresponding to the entitled data
-- set being viewed. This parameter is returned when a data set owner is
-- viewing the entitled copy of its owned data set.
createDataSetResponse_sourceId :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.Text)
createDataSetResponse_sourceId :: Lens' CreateDataSetResponse (Maybe Text)
createDataSetResponse_sourceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe Text
sourceId :: Maybe Text
$sel:sourceId:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
sourceId} -> Maybe Text
sourceId) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe Text
a -> CreateDataSetResponse
s {$sel:sourceId:CreateDataSetResponse' :: Maybe Text
sourceId = Maybe Text
a} :: CreateDataSetResponse)

-- | The tags for the data set.
createDataSetResponse_tags :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createDataSetResponse_tags :: Lens' CreateDataSetResponse (Maybe (HashMap Text Text))
createDataSetResponse_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe (HashMap Text Text)
a -> CreateDataSetResponse
s {$sel:tags:CreateDataSetResponse' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateDataSetResponse) 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 date and time that the data set was last updated, in ISO 8601
-- format.
createDataSetResponse_updatedAt :: Lens.Lens' CreateDataSetResponse (Prelude.Maybe Prelude.UTCTime)
createDataSetResponse_updatedAt :: Lens' CreateDataSetResponse (Maybe UTCTime)
createDataSetResponse_updatedAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetResponse' {Maybe ISO8601
updatedAt :: Maybe ISO8601
$sel:updatedAt:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe ISO8601
updatedAt} -> Maybe ISO8601
updatedAt) (\s :: CreateDataSetResponse
s@CreateDataSetResponse' {} Maybe ISO8601
a -> CreateDataSetResponse
s {$sel:updatedAt:CreateDataSetResponse' :: Maybe ISO8601
updatedAt = Maybe ISO8601
a} :: CreateDataSetResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | 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 (HashMap Text Text)
Maybe ISO8601
Maybe AssetType
Maybe Origin
Maybe OriginDetails
httpStatus :: Int
updatedAt :: Maybe ISO8601
tags :: Maybe (HashMap Text Text)
sourceId :: Maybe Text
originDetails :: Maybe OriginDetails
origin :: Maybe Origin
name :: Maybe Text
id :: Maybe Text
description :: Maybe Text
createdAt :: Maybe ISO8601
assetType :: Maybe AssetType
arn :: Maybe Text
$sel:httpStatus:CreateDataSetResponse' :: CreateDataSetResponse -> Int
$sel:updatedAt:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe ISO8601
$sel:tags:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe (HashMap Text Text)
$sel:sourceId:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
$sel:originDetails:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe OriginDetails
$sel:origin:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Origin
$sel:name:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
$sel:id:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
$sel:description:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
$sel:createdAt:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe ISO8601
$sel:assetType:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe AssetType
$sel:arn:CreateDataSetResponse' :: CreateDataSetResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AssetType
assetType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
createdAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Origin
origin
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe OriginDetails
originDetails
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
sourceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
updatedAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus