{-# 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.Personalize.CreateDatasetGroup
-- 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 an empty dataset group. A dataset group is a container for
-- Amazon Personalize resources. A dataset group can contain at most three
-- datasets, one for each type of dataset:
--
-- -   Interactions
--
-- -   Items
--
-- -   Users
--
-- A dataset group can be a Domain dataset group, where you specify a
-- domain and use pre-configured resources like recommenders, or a Custom
-- dataset group, where you use custom resources, such as a solution with a
-- solution version, that you deploy with a campaign. If you start with a
-- Domain dataset group, you can still add custom resources such as
-- solutions and solution versions trained with recipes for custom use
-- cases and deployed with campaigns.
--
-- A dataset group can be in one of the following states:
--
-- -   CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED
--
-- -   DELETE PENDING
--
-- To get the status of the dataset group, call
-- <https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetGroup.html DescribeDatasetGroup>.
-- If the status shows as CREATE FAILED, the response includes a
-- @failureReason@ key, which describes why the creation failed.
--
-- You must wait until the @status@ of the dataset group is @ACTIVE@ before
-- adding a dataset to the group.
--
-- You can specify an Key Management Service (KMS) key to encrypt the
-- datasets in the group. If you specify a KMS key, you must also include
-- an Identity and Access Management (IAM) role that has permission to
-- access the key.
--
-- __APIs that require a dataset group ARN in the request__
--
-- -   <https://docs.aws.amazon.com/personalize/latest/dg/API_CreateDataset.html CreateDataset>
--
-- -   <https://docs.aws.amazon.com/personalize/latest/dg/API_CreateEventTracker.html CreateEventTracker>
--
-- -   <https://docs.aws.amazon.com/personalize/latest/dg/API_CreateSolution.html CreateSolution>
--
-- __Related APIs__
--
-- -   <https://docs.aws.amazon.com/personalize/latest/dg/API_ListDatasetGroups.html ListDatasetGroups>
--
-- -   <https://docs.aws.amazon.com/personalize/latest/dg/API_DescribeDatasetGroup.html DescribeDatasetGroup>
--
-- -   <https://docs.aws.amazon.com/personalize/latest/dg/API_DeleteDatasetGroup.html DeleteDatasetGroup>
module Amazonka.Personalize.CreateDatasetGroup
  ( -- * Creating a Request
    CreateDatasetGroup (..),
    newCreateDatasetGroup,

    -- * Request Lenses
    createDatasetGroup_domain,
    createDatasetGroup_kmsKeyArn,
    createDatasetGroup_roleArn,
    createDatasetGroup_tags,
    createDatasetGroup_name,

    -- * Destructuring the Response
    CreateDatasetGroupResponse (..),
    newCreateDatasetGroupResponse,

    -- * Response Lenses
    createDatasetGroupResponse_datasetGroupArn,
    createDatasetGroupResponse_domain,
    createDatasetGroupResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateDatasetGroup' smart constructor.
data CreateDatasetGroup = CreateDatasetGroup'
  { -- | The domain of the dataset group. Specify a domain to create a Domain
    -- dataset group. The domain you specify determines the default schemas for
    -- datasets and the use cases available for recommenders. If you don\'t
    -- specify a domain, you create a Custom dataset group with solution
    -- versions that you deploy with a campaign.
    CreateDatasetGroup -> Maybe Domain
domain :: Prelude.Maybe Domain,
    -- | The Amazon Resource Name (ARN) of a Key Management Service (KMS) key
    -- used to encrypt the datasets.
    CreateDatasetGroup -> Maybe Text
kmsKeyArn :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the Identity and Access Management (IAM) role that has
    -- permissions to access the Key Management Service (KMS) key. Supplying an
    -- IAM role is only valid when also specifying a KMS key.
    CreateDatasetGroup -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text,
    -- | A list of
    -- <https://docs.aws.amazon.com/personalize/latest/dev/tagging-resources.html tags>
    -- to apply to the dataset group.
    CreateDatasetGroup -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name for the new dataset group.
    CreateDatasetGroup -> Text
name :: Prelude.Text
  }
  deriving (CreateDatasetGroup -> CreateDatasetGroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDatasetGroup -> CreateDatasetGroup -> Bool
$c/= :: CreateDatasetGroup -> CreateDatasetGroup -> Bool
== :: CreateDatasetGroup -> CreateDatasetGroup -> Bool
$c== :: CreateDatasetGroup -> CreateDatasetGroup -> Bool
Prelude.Eq, ReadPrec [CreateDatasetGroup]
ReadPrec CreateDatasetGroup
Int -> ReadS CreateDatasetGroup
ReadS [CreateDatasetGroup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDatasetGroup]
$creadListPrec :: ReadPrec [CreateDatasetGroup]
readPrec :: ReadPrec CreateDatasetGroup
$creadPrec :: ReadPrec CreateDatasetGroup
readList :: ReadS [CreateDatasetGroup]
$creadList :: ReadS [CreateDatasetGroup]
readsPrec :: Int -> ReadS CreateDatasetGroup
$creadsPrec :: Int -> ReadS CreateDatasetGroup
Prelude.Read, Int -> CreateDatasetGroup -> ShowS
[CreateDatasetGroup] -> ShowS
CreateDatasetGroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDatasetGroup] -> ShowS
$cshowList :: [CreateDatasetGroup] -> ShowS
show :: CreateDatasetGroup -> String
$cshow :: CreateDatasetGroup -> String
showsPrec :: Int -> CreateDatasetGroup -> ShowS
$cshowsPrec :: Int -> CreateDatasetGroup -> ShowS
Prelude.Show, forall x. Rep CreateDatasetGroup x -> CreateDatasetGroup
forall x. CreateDatasetGroup -> Rep CreateDatasetGroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDatasetGroup x -> CreateDatasetGroup
$cfrom :: forall x. CreateDatasetGroup -> Rep CreateDatasetGroup x
Prelude.Generic)

-- |
-- Create a value of 'CreateDatasetGroup' 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:
--
-- 'domain', 'createDatasetGroup_domain' - The domain of the dataset group. Specify a domain to create a Domain
-- dataset group. The domain you specify determines the default schemas for
-- datasets and the use cases available for recommenders. If you don\'t
-- specify a domain, you create a Custom dataset group with solution
-- versions that you deploy with a campaign.
--
-- 'kmsKeyArn', 'createDatasetGroup_kmsKeyArn' - The Amazon Resource Name (ARN) of a Key Management Service (KMS) key
-- used to encrypt the datasets.
--
-- 'roleArn', 'createDatasetGroup_roleArn' - The ARN of the Identity and Access Management (IAM) role that has
-- permissions to access the Key Management Service (KMS) key. Supplying an
-- IAM role is only valid when also specifying a KMS key.
--
-- 'tags', 'createDatasetGroup_tags' - A list of
-- <https://docs.aws.amazon.com/personalize/latest/dev/tagging-resources.html tags>
-- to apply to the dataset group.
--
-- 'name', 'createDatasetGroup_name' - The name for the new dataset group.
newCreateDatasetGroup ::
  -- | 'name'
  Prelude.Text ->
  CreateDatasetGroup
newCreateDatasetGroup :: Text -> CreateDatasetGroup
newCreateDatasetGroup Text
pName_ =
  CreateDatasetGroup'
    { $sel:domain:CreateDatasetGroup' :: Maybe Domain
domain = forall a. Maybe a
Prelude.Nothing,
      $sel:kmsKeyArn:CreateDatasetGroup' :: Maybe Text
kmsKeyArn = forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:CreateDatasetGroup' :: Maybe Text
roleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateDatasetGroup' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateDatasetGroup' :: Text
name = Text
pName_
    }

-- | The domain of the dataset group. Specify a domain to create a Domain
-- dataset group. The domain you specify determines the default schemas for
-- datasets and the use cases available for recommenders. If you don\'t
-- specify a domain, you create a Custom dataset group with solution
-- versions that you deploy with a campaign.
createDatasetGroup_domain :: Lens.Lens' CreateDatasetGroup (Prelude.Maybe Domain)
createDatasetGroup_domain :: Lens' CreateDatasetGroup (Maybe Domain)
createDatasetGroup_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroup' {Maybe Domain
domain :: Maybe Domain
$sel:domain:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Domain
domain} -> Maybe Domain
domain) (\s :: CreateDatasetGroup
s@CreateDatasetGroup' {} Maybe Domain
a -> CreateDatasetGroup
s {$sel:domain:CreateDatasetGroup' :: Maybe Domain
domain = Maybe Domain
a} :: CreateDatasetGroup)

-- | The Amazon Resource Name (ARN) of a Key Management Service (KMS) key
-- used to encrypt the datasets.
createDatasetGroup_kmsKeyArn :: Lens.Lens' CreateDatasetGroup (Prelude.Maybe Prelude.Text)
createDatasetGroup_kmsKeyArn :: Lens' CreateDatasetGroup (Maybe Text)
createDatasetGroup_kmsKeyArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroup' {Maybe Text
kmsKeyArn :: Maybe Text
$sel:kmsKeyArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
kmsKeyArn} -> Maybe Text
kmsKeyArn) (\s :: CreateDatasetGroup
s@CreateDatasetGroup' {} Maybe Text
a -> CreateDatasetGroup
s {$sel:kmsKeyArn:CreateDatasetGroup' :: Maybe Text
kmsKeyArn = Maybe Text
a} :: CreateDatasetGroup)

-- | The ARN of the Identity and Access Management (IAM) role that has
-- permissions to access the Key Management Service (KMS) key. Supplying an
-- IAM role is only valid when also specifying a KMS key.
createDatasetGroup_roleArn :: Lens.Lens' CreateDatasetGroup (Prelude.Maybe Prelude.Text)
createDatasetGroup_roleArn :: Lens' CreateDatasetGroup (Maybe Text)
createDatasetGroup_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroup' {Maybe Text
roleArn :: Maybe Text
$sel:roleArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
roleArn} -> Maybe Text
roleArn) (\s :: CreateDatasetGroup
s@CreateDatasetGroup' {} Maybe Text
a -> CreateDatasetGroup
s {$sel:roleArn:CreateDatasetGroup' :: Maybe Text
roleArn = Maybe Text
a} :: CreateDatasetGroup)

-- | A list of
-- <https://docs.aws.amazon.com/personalize/latest/dev/tagging-resources.html tags>
-- to apply to the dataset group.
createDatasetGroup_tags :: Lens.Lens' CreateDatasetGroup (Prelude.Maybe [Tag])
createDatasetGroup_tags :: Lens' CreateDatasetGroup (Maybe [Tag])
createDatasetGroup_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroup' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateDatasetGroup
s@CreateDatasetGroup' {} Maybe [Tag]
a -> CreateDatasetGroup
s {$sel:tags:CreateDatasetGroup' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateDatasetGroup) 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 for the new dataset group.
createDatasetGroup_name :: Lens.Lens' CreateDatasetGroup Prelude.Text
createDatasetGroup_name :: Lens' CreateDatasetGroup Text
createDatasetGroup_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroup' {Text
name :: Text
$sel:name:CreateDatasetGroup' :: CreateDatasetGroup -> Text
name} -> Text
name) (\s :: CreateDatasetGroup
s@CreateDatasetGroup' {} Text
a -> CreateDatasetGroup
s {$sel:name:CreateDatasetGroup' :: Text
name = Text
a} :: CreateDatasetGroup)

instance Core.AWSRequest CreateDatasetGroup where
  type
    AWSResponse CreateDatasetGroup =
      CreateDatasetGroupResponse
  request :: (Service -> Service)
-> CreateDatasetGroup -> Request CreateDatasetGroup
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 CreateDatasetGroup
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateDatasetGroup)))
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 Domain -> Int -> CreateDatasetGroupResponse
CreateDatasetGroupResponse'
            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
"datasetGroupArn")
            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
"domain")
            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 CreateDatasetGroup where
  hashWithSalt :: Int -> CreateDatasetGroup -> Int
hashWithSalt Int
_salt CreateDatasetGroup' {Maybe [Tag]
Maybe Text
Maybe Domain
Text
name :: Text
tags :: Maybe [Tag]
roleArn :: Maybe Text
kmsKeyArn :: Maybe Text
domain :: Maybe Domain
$sel:name:CreateDatasetGroup' :: CreateDatasetGroup -> Text
$sel:tags:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe [Tag]
$sel:roleArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
$sel:kmsKeyArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
$sel:domain:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Domain
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Domain
domain
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
kmsKeyArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
roleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateDatasetGroup where
  rnf :: CreateDatasetGroup -> ()
rnf CreateDatasetGroup' {Maybe [Tag]
Maybe Text
Maybe Domain
Text
name :: Text
tags :: Maybe [Tag]
roleArn :: Maybe Text
kmsKeyArn :: Maybe Text
domain :: Maybe Domain
$sel:name:CreateDatasetGroup' :: CreateDatasetGroup -> Text
$sel:tags:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe [Tag]
$sel:roleArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
$sel:kmsKeyArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
$sel:domain:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Domain
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Domain
domain
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
kmsKeyArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roleArn
      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
name

instance Data.ToHeaders CreateDatasetGroup where
  toHeaders :: CreateDatasetGroup -> 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
"AmazonPersonalize.CreateDatasetGroup" ::
                          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 CreateDatasetGroup where
  toJSON :: CreateDatasetGroup -> Value
toJSON CreateDatasetGroup' {Maybe [Tag]
Maybe Text
Maybe Domain
Text
name :: Text
tags :: Maybe [Tag]
roleArn :: Maybe Text
kmsKeyArn :: Maybe Text
domain :: Maybe Domain
$sel:name:CreateDatasetGroup' :: CreateDatasetGroup -> Text
$sel:tags:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe [Tag]
$sel:roleArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
$sel:kmsKeyArn:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Text
$sel:domain:CreateDatasetGroup' :: CreateDatasetGroup -> Maybe Domain
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"domain" 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 Domain
domain,
            (Key
"kmsKeyArn" 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
kmsKeyArn,
            (Key
"roleArn" 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
roleArn,
            (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
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

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

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

-- | /See:/ 'newCreateDatasetGroupResponse' smart constructor.
data CreateDatasetGroupResponse = CreateDatasetGroupResponse'
  { -- | The Amazon Resource Name (ARN) of the new dataset group.
    CreateDatasetGroupResponse -> Maybe Text
datasetGroupArn :: Prelude.Maybe Prelude.Text,
    -- | The domain for the new Domain dataset group.
    CreateDatasetGroupResponse -> Maybe Domain
domain :: Prelude.Maybe Domain,
    -- | The response's http status code.
    CreateDatasetGroupResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateDatasetGroupResponse -> CreateDatasetGroupResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDatasetGroupResponse -> CreateDatasetGroupResponse -> Bool
$c/= :: CreateDatasetGroupResponse -> CreateDatasetGroupResponse -> Bool
== :: CreateDatasetGroupResponse -> CreateDatasetGroupResponse -> Bool
$c== :: CreateDatasetGroupResponse -> CreateDatasetGroupResponse -> Bool
Prelude.Eq, ReadPrec [CreateDatasetGroupResponse]
ReadPrec CreateDatasetGroupResponse
Int -> ReadS CreateDatasetGroupResponse
ReadS [CreateDatasetGroupResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDatasetGroupResponse]
$creadListPrec :: ReadPrec [CreateDatasetGroupResponse]
readPrec :: ReadPrec CreateDatasetGroupResponse
$creadPrec :: ReadPrec CreateDatasetGroupResponse
readList :: ReadS [CreateDatasetGroupResponse]
$creadList :: ReadS [CreateDatasetGroupResponse]
readsPrec :: Int -> ReadS CreateDatasetGroupResponse
$creadsPrec :: Int -> ReadS CreateDatasetGroupResponse
Prelude.Read, Int -> CreateDatasetGroupResponse -> ShowS
[CreateDatasetGroupResponse] -> ShowS
CreateDatasetGroupResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDatasetGroupResponse] -> ShowS
$cshowList :: [CreateDatasetGroupResponse] -> ShowS
show :: CreateDatasetGroupResponse -> String
$cshow :: CreateDatasetGroupResponse -> String
showsPrec :: Int -> CreateDatasetGroupResponse -> ShowS
$cshowsPrec :: Int -> CreateDatasetGroupResponse -> ShowS
Prelude.Show, forall x.
Rep CreateDatasetGroupResponse x -> CreateDatasetGroupResponse
forall x.
CreateDatasetGroupResponse -> Rep CreateDatasetGroupResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateDatasetGroupResponse x -> CreateDatasetGroupResponse
$cfrom :: forall x.
CreateDatasetGroupResponse -> Rep CreateDatasetGroupResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDatasetGroupResponse' 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:
--
-- 'datasetGroupArn', 'createDatasetGroupResponse_datasetGroupArn' - The Amazon Resource Name (ARN) of the new dataset group.
--
-- 'domain', 'createDatasetGroupResponse_domain' - The domain for the new Domain dataset group.
--
-- 'httpStatus', 'createDatasetGroupResponse_httpStatus' - The response's http status code.
newCreateDatasetGroupResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDatasetGroupResponse
newCreateDatasetGroupResponse :: Int -> CreateDatasetGroupResponse
newCreateDatasetGroupResponse Int
pHttpStatus_ =
  CreateDatasetGroupResponse'
    { $sel:datasetGroupArn:CreateDatasetGroupResponse' :: Maybe Text
datasetGroupArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:domain:CreateDatasetGroupResponse' :: Maybe Domain
domain = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDatasetGroupResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the new dataset group.
createDatasetGroupResponse_datasetGroupArn :: Lens.Lens' CreateDatasetGroupResponse (Prelude.Maybe Prelude.Text)
createDatasetGroupResponse_datasetGroupArn :: Lens' CreateDatasetGroupResponse (Maybe Text)
createDatasetGroupResponse_datasetGroupArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroupResponse' {Maybe Text
datasetGroupArn :: Maybe Text
$sel:datasetGroupArn:CreateDatasetGroupResponse' :: CreateDatasetGroupResponse -> Maybe Text
datasetGroupArn} -> Maybe Text
datasetGroupArn) (\s :: CreateDatasetGroupResponse
s@CreateDatasetGroupResponse' {} Maybe Text
a -> CreateDatasetGroupResponse
s {$sel:datasetGroupArn:CreateDatasetGroupResponse' :: Maybe Text
datasetGroupArn = Maybe Text
a} :: CreateDatasetGroupResponse)

-- | The domain for the new Domain dataset group.
createDatasetGroupResponse_domain :: Lens.Lens' CreateDatasetGroupResponse (Prelude.Maybe Domain)
createDatasetGroupResponse_domain :: Lens' CreateDatasetGroupResponse (Maybe Domain)
createDatasetGroupResponse_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDatasetGroupResponse' {Maybe Domain
domain :: Maybe Domain
$sel:domain:CreateDatasetGroupResponse' :: CreateDatasetGroupResponse -> Maybe Domain
domain} -> Maybe Domain
domain) (\s :: CreateDatasetGroupResponse
s@CreateDatasetGroupResponse' {} Maybe Domain
a -> CreateDatasetGroupResponse
s {$sel:domain:CreateDatasetGroupResponse' :: Maybe Domain
domain = Maybe Domain
a} :: CreateDatasetGroupResponse)

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

instance Prelude.NFData CreateDatasetGroupResponse where
  rnf :: CreateDatasetGroupResponse -> ()
rnf CreateDatasetGroupResponse' {Int
Maybe Text
Maybe Domain
httpStatus :: Int
domain :: Maybe Domain
datasetGroupArn :: Maybe Text
$sel:httpStatus:CreateDatasetGroupResponse' :: CreateDatasetGroupResponse -> Int
$sel:domain:CreateDatasetGroupResponse' :: CreateDatasetGroupResponse -> Maybe Domain
$sel:datasetGroupArn:CreateDatasetGroupResponse' :: CreateDatasetGroupResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
datasetGroupArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Domain
domain
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus