{-# 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.RedshiftServerLess.CreateNamespace
-- 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 namespace in Amazon Redshift Serverless.
module Amazonka.RedshiftServerLess.CreateNamespace
  ( -- * Creating a Request
    CreateNamespace (..),
    newCreateNamespace,

    -- * Request Lenses
    createNamespace_adminUserPassword,
    createNamespace_adminUsername,
    createNamespace_dbName,
    createNamespace_defaultIamRoleArn,
    createNamespace_iamRoles,
    createNamespace_kmsKeyId,
    createNamespace_logExports,
    createNamespace_tags,
    createNamespace_namespaceName,

    -- * Destructuring the Response
    CreateNamespaceResponse (..),
    newCreateNamespaceResponse,

    -- * Response Lenses
    createNamespaceResponse_namespace,
    createNamespaceResponse_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 Amazonka.RedshiftServerLess.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateNamespace' smart constructor.
data CreateNamespace = CreateNamespace'
  { -- | The password of the administrator for the first database created in the
    -- namespace.
    CreateNamespace -> Maybe (Sensitive Text)
adminUserPassword :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The username of the administrator for the first database created in the
    -- namespace.
    CreateNamespace -> Maybe (Sensitive Text)
adminUsername :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The name of the first database created in the namespace.
    CreateNamespace -> Maybe Text
dbName :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the IAM role to set as a default in
    -- the namespace.
    CreateNamespace -> Maybe Text
defaultIamRoleArn :: Prelude.Maybe Prelude.Text,
    -- | A list of IAM roles to associate with the namespace.
    CreateNamespace -> Maybe [Text]
iamRoles :: Prelude.Maybe [Prelude.Text],
    -- | The ID of the Amazon Web Services Key Management Service key used to
    -- encrypt your data.
    CreateNamespace -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | The types of logs the namespace can export. Available export types are
    -- @userlog@, @connectionlog@, and @useractivitylog@.
    CreateNamespace -> Maybe [LogExport]
logExports :: Prelude.Maybe [LogExport],
    -- | A list of tag instances.
    CreateNamespace -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the namespace.
    CreateNamespace -> Text
namespaceName :: Prelude.Text
  }
  deriving (CreateNamespace -> CreateNamespace -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateNamespace -> CreateNamespace -> Bool
$c/= :: CreateNamespace -> CreateNamespace -> Bool
== :: CreateNamespace -> CreateNamespace -> Bool
$c== :: CreateNamespace -> CreateNamespace -> Bool
Prelude.Eq, Int -> CreateNamespace -> ShowS
[CreateNamespace] -> ShowS
CreateNamespace -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateNamespace] -> ShowS
$cshowList :: [CreateNamespace] -> ShowS
show :: CreateNamespace -> String
$cshow :: CreateNamespace -> String
showsPrec :: Int -> CreateNamespace -> ShowS
$cshowsPrec :: Int -> CreateNamespace -> ShowS
Prelude.Show, forall x. Rep CreateNamespace x -> CreateNamespace
forall x. CreateNamespace -> Rep CreateNamespace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateNamespace x -> CreateNamespace
$cfrom :: forall x. CreateNamespace -> Rep CreateNamespace x
Prelude.Generic)

-- |
-- Create a value of 'CreateNamespace' 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:
--
-- 'adminUserPassword', 'createNamespace_adminUserPassword' - The password of the administrator for the first database created in the
-- namespace.
--
-- 'adminUsername', 'createNamespace_adminUsername' - The username of the administrator for the first database created in the
-- namespace.
--
-- 'dbName', 'createNamespace_dbName' - The name of the first database created in the namespace.
--
-- 'defaultIamRoleArn', 'createNamespace_defaultIamRoleArn' - The Amazon Resource Name (ARN) of the IAM role to set as a default in
-- the namespace.
--
-- 'iamRoles', 'createNamespace_iamRoles' - A list of IAM roles to associate with the namespace.
--
-- 'kmsKeyId', 'createNamespace_kmsKeyId' - The ID of the Amazon Web Services Key Management Service key used to
-- encrypt your data.
--
-- 'logExports', 'createNamespace_logExports' - The types of logs the namespace can export. Available export types are
-- @userlog@, @connectionlog@, and @useractivitylog@.
--
-- 'tags', 'createNamespace_tags' - A list of tag instances.
--
-- 'namespaceName', 'createNamespace_namespaceName' - The name of the namespace.
newCreateNamespace ::
  -- | 'namespaceName'
  Prelude.Text ->
  CreateNamespace
newCreateNamespace :: Text -> CreateNamespace
newCreateNamespace Text
pNamespaceName_ =
  CreateNamespace'
    { $sel:adminUserPassword:CreateNamespace' :: Maybe (Sensitive Text)
adminUserPassword =
        forall a. Maybe a
Prelude.Nothing,
      $sel:adminUsername:CreateNamespace' :: Maybe (Sensitive Text)
adminUsername = forall a. Maybe a
Prelude.Nothing,
      $sel:dbName:CreateNamespace' :: Maybe Text
dbName = forall a. Maybe a
Prelude.Nothing,
      $sel:defaultIamRoleArn:CreateNamespace' :: Maybe Text
defaultIamRoleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:iamRoles:CreateNamespace' :: Maybe [Text]
iamRoles = forall a. Maybe a
Prelude.Nothing,
      $sel:kmsKeyId:CreateNamespace' :: Maybe Text
kmsKeyId = forall a. Maybe a
Prelude.Nothing,
      $sel:logExports:CreateNamespace' :: Maybe [LogExport]
logExports = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateNamespace' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:namespaceName:CreateNamespace' :: Text
namespaceName = Text
pNamespaceName_
    }

-- | The password of the administrator for the first database created in the
-- namespace.
createNamespace_adminUserPassword :: Lens.Lens' CreateNamespace (Prelude.Maybe Prelude.Text)
createNamespace_adminUserPassword :: Lens' CreateNamespace (Maybe Text)
createNamespace_adminUserPassword = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe (Sensitive Text)
adminUserPassword :: Maybe (Sensitive Text)
$sel:adminUserPassword:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
adminUserPassword} -> Maybe (Sensitive Text)
adminUserPassword) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe (Sensitive Text)
a -> CreateNamespace
s {$sel:adminUserPassword:CreateNamespace' :: Maybe (Sensitive Text)
adminUserPassword = Maybe (Sensitive Text)
a} :: CreateNamespace) 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. Iso' (Sensitive a) a
Data._Sensitive

-- | The username of the administrator for the first database created in the
-- namespace.
createNamespace_adminUsername :: Lens.Lens' CreateNamespace (Prelude.Maybe Prelude.Text)
createNamespace_adminUsername :: Lens' CreateNamespace (Maybe Text)
createNamespace_adminUsername = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe (Sensitive Text)
adminUsername :: Maybe (Sensitive Text)
$sel:adminUsername:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
adminUsername} -> Maybe (Sensitive Text)
adminUsername) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe (Sensitive Text)
a -> CreateNamespace
s {$sel:adminUsername:CreateNamespace' :: Maybe (Sensitive Text)
adminUsername = Maybe (Sensitive Text)
a} :: CreateNamespace) 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. Iso' (Sensitive a) a
Data._Sensitive

-- | The name of the first database created in the namespace.
createNamespace_dbName :: Lens.Lens' CreateNamespace (Prelude.Maybe Prelude.Text)
createNamespace_dbName :: Lens' CreateNamespace (Maybe Text)
createNamespace_dbName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe Text
dbName :: Maybe Text
$sel:dbName:CreateNamespace' :: CreateNamespace -> Maybe Text
dbName} -> Maybe Text
dbName) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe Text
a -> CreateNamespace
s {$sel:dbName:CreateNamespace' :: Maybe Text
dbName = Maybe Text
a} :: CreateNamespace)

-- | The Amazon Resource Name (ARN) of the IAM role to set as a default in
-- the namespace.
createNamespace_defaultIamRoleArn :: Lens.Lens' CreateNamespace (Prelude.Maybe Prelude.Text)
createNamespace_defaultIamRoleArn :: Lens' CreateNamespace (Maybe Text)
createNamespace_defaultIamRoleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe Text
defaultIamRoleArn :: Maybe Text
$sel:defaultIamRoleArn:CreateNamespace' :: CreateNamespace -> Maybe Text
defaultIamRoleArn} -> Maybe Text
defaultIamRoleArn) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe Text
a -> CreateNamespace
s {$sel:defaultIamRoleArn:CreateNamespace' :: Maybe Text
defaultIamRoleArn = Maybe Text
a} :: CreateNamespace)

-- | A list of IAM roles to associate with the namespace.
createNamespace_iamRoles :: Lens.Lens' CreateNamespace (Prelude.Maybe [Prelude.Text])
createNamespace_iamRoles :: Lens' CreateNamespace (Maybe [Text])
createNamespace_iamRoles = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe [Text]
iamRoles :: Maybe [Text]
$sel:iamRoles:CreateNamespace' :: CreateNamespace -> Maybe [Text]
iamRoles} -> Maybe [Text]
iamRoles) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe [Text]
a -> CreateNamespace
s {$sel:iamRoles:CreateNamespace' :: Maybe [Text]
iamRoles = Maybe [Text]
a} :: CreateNamespace) 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 ID of the Amazon Web Services Key Management Service key used to
-- encrypt your data.
createNamespace_kmsKeyId :: Lens.Lens' CreateNamespace (Prelude.Maybe Prelude.Text)
createNamespace_kmsKeyId :: Lens' CreateNamespace (Maybe Text)
createNamespace_kmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:CreateNamespace' :: CreateNamespace -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe Text
a -> CreateNamespace
s {$sel:kmsKeyId:CreateNamespace' :: Maybe Text
kmsKeyId = Maybe Text
a} :: CreateNamespace)

-- | The types of logs the namespace can export. Available export types are
-- @userlog@, @connectionlog@, and @useractivitylog@.
createNamespace_logExports :: Lens.Lens' CreateNamespace (Prelude.Maybe [LogExport])
createNamespace_logExports :: Lens' CreateNamespace (Maybe [LogExport])
createNamespace_logExports = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe [LogExport]
logExports :: Maybe [LogExport]
$sel:logExports:CreateNamespace' :: CreateNamespace -> Maybe [LogExport]
logExports} -> Maybe [LogExport]
logExports) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe [LogExport]
a -> CreateNamespace
s {$sel:logExports:CreateNamespace' :: Maybe [LogExport]
logExports = Maybe [LogExport]
a} :: CreateNamespace) 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

-- | A list of tag instances.
createNamespace_tags :: Lens.Lens' CreateNamespace (Prelude.Maybe [Tag])
createNamespace_tags :: Lens' CreateNamespace (Maybe [Tag])
createNamespace_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateNamespace' :: CreateNamespace -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateNamespace
s@CreateNamespace' {} Maybe [Tag]
a -> CreateNamespace
s {$sel:tags:CreateNamespace' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateNamespace) 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 namespace.
createNamespace_namespaceName :: Lens.Lens' CreateNamespace Prelude.Text
createNamespace_namespaceName :: Lens' CreateNamespace Text
createNamespace_namespaceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespace' {Text
namespaceName :: Text
$sel:namespaceName:CreateNamespace' :: CreateNamespace -> Text
namespaceName} -> Text
namespaceName) (\s :: CreateNamespace
s@CreateNamespace' {} Text
a -> CreateNamespace
s {$sel:namespaceName:CreateNamespace' :: Text
namespaceName = Text
a} :: CreateNamespace)

instance Core.AWSRequest CreateNamespace where
  type
    AWSResponse CreateNamespace =
      CreateNamespaceResponse
  request :: (Service -> Service) -> CreateNamespace -> Request CreateNamespace
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 CreateNamespace
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateNamespace)))
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 Namespace -> Int -> CreateNamespaceResponse
CreateNamespaceResponse'
            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
"namespace")
            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 CreateNamespace where
  hashWithSalt :: Int -> CreateNamespace -> Int
hashWithSalt Int
_salt CreateNamespace' {Maybe [Text]
Maybe [LogExport]
Maybe [Tag]
Maybe Text
Maybe (Sensitive Text)
Text
namespaceName :: Text
tags :: Maybe [Tag]
logExports :: Maybe [LogExport]
kmsKeyId :: Maybe Text
iamRoles :: Maybe [Text]
defaultIamRoleArn :: Maybe Text
dbName :: Maybe Text
adminUsername :: Maybe (Sensitive Text)
adminUserPassword :: Maybe (Sensitive Text)
$sel:namespaceName:CreateNamespace' :: CreateNamespace -> Text
$sel:tags:CreateNamespace' :: CreateNamespace -> Maybe [Tag]
$sel:logExports:CreateNamespace' :: CreateNamespace -> Maybe [LogExport]
$sel:kmsKeyId:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:iamRoles:CreateNamespace' :: CreateNamespace -> Maybe [Text]
$sel:defaultIamRoleArn:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:dbName:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:adminUsername:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
$sel:adminUserPassword:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
adminUserPassword
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
adminUsername
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
defaultIamRoleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
iamRoles
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
kmsKeyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LogExport]
logExports
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
namespaceName

instance Prelude.NFData CreateNamespace where
  rnf :: CreateNamespace -> ()
rnf CreateNamespace' {Maybe [Text]
Maybe [LogExport]
Maybe [Tag]
Maybe Text
Maybe (Sensitive Text)
Text
namespaceName :: Text
tags :: Maybe [Tag]
logExports :: Maybe [LogExport]
kmsKeyId :: Maybe Text
iamRoles :: Maybe [Text]
defaultIamRoleArn :: Maybe Text
dbName :: Maybe Text
adminUsername :: Maybe (Sensitive Text)
adminUserPassword :: Maybe (Sensitive Text)
$sel:namespaceName:CreateNamespace' :: CreateNamespace -> Text
$sel:tags:CreateNamespace' :: CreateNamespace -> Maybe [Tag]
$sel:logExports:CreateNamespace' :: CreateNamespace -> Maybe [LogExport]
$sel:kmsKeyId:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:iamRoles:CreateNamespace' :: CreateNamespace -> Maybe [Text]
$sel:defaultIamRoleArn:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:dbName:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:adminUsername:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
$sel:adminUserPassword:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
adminUserPassword
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
adminUsername
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
defaultIamRoleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
iamRoles
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
kmsKeyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [LogExport]
logExports
      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
namespaceName

instance Data.ToHeaders CreateNamespace where
  toHeaders :: CreateNamespace -> 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
"RedshiftServerless.CreateNamespace" ::
                          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 CreateNamespace where
  toJSON :: CreateNamespace -> Value
toJSON CreateNamespace' {Maybe [Text]
Maybe [LogExport]
Maybe [Tag]
Maybe Text
Maybe (Sensitive Text)
Text
namespaceName :: Text
tags :: Maybe [Tag]
logExports :: Maybe [LogExport]
kmsKeyId :: Maybe Text
iamRoles :: Maybe [Text]
defaultIamRoleArn :: Maybe Text
dbName :: Maybe Text
adminUsername :: Maybe (Sensitive Text)
adminUserPassword :: Maybe (Sensitive Text)
$sel:namespaceName:CreateNamespace' :: CreateNamespace -> Text
$sel:tags:CreateNamespace' :: CreateNamespace -> Maybe [Tag]
$sel:logExports:CreateNamespace' :: CreateNamespace -> Maybe [LogExport]
$sel:kmsKeyId:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:iamRoles:CreateNamespace' :: CreateNamespace -> Maybe [Text]
$sel:defaultIamRoleArn:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:dbName:CreateNamespace' :: CreateNamespace -> Maybe Text
$sel:adminUsername:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
$sel:adminUserPassword:CreateNamespace' :: CreateNamespace -> Maybe (Sensitive Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"adminUserPassword" 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 (Sensitive Text)
adminUserPassword,
            (Key
"adminUsername" 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 (Sensitive Text)
adminUsername,
            (Key
"dbName" 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
dbName,
            (Key
"defaultIamRoleArn" 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
defaultIamRoleArn,
            (Key
"iamRoles" 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]
iamRoles,
            (Key
"kmsKeyId" 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
kmsKeyId,
            (Key
"logExports" 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 [LogExport]
logExports,
            (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
"namespaceName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
namespaceName)
          ]
      )

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

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

-- | /See:/ 'newCreateNamespaceResponse' smart constructor.
data CreateNamespaceResponse = CreateNamespaceResponse'
  { -- | The created namespace object.
    CreateNamespaceResponse -> Maybe Namespace
namespace :: Prelude.Maybe Namespace,
    -- | The response's http status code.
    CreateNamespaceResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateNamespaceResponse -> CreateNamespaceResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateNamespaceResponse -> CreateNamespaceResponse -> Bool
$c/= :: CreateNamespaceResponse -> CreateNamespaceResponse -> Bool
== :: CreateNamespaceResponse -> CreateNamespaceResponse -> Bool
$c== :: CreateNamespaceResponse -> CreateNamespaceResponse -> Bool
Prelude.Eq, Int -> CreateNamespaceResponse -> ShowS
[CreateNamespaceResponse] -> ShowS
CreateNamespaceResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateNamespaceResponse] -> ShowS
$cshowList :: [CreateNamespaceResponse] -> ShowS
show :: CreateNamespaceResponse -> String
$cshow :: CreateNamespaceResponse -> String
showsPrec :: Int -> CreateNamespaceResponse -> ShowS
$cshowsPrec :: Int -> CreateNamespaceResponse -> ShowS
Prelude.Show, forall x. Rep CreateNamespaceResponse x -> CreateNamespaceResponse
forall x. CreateNamespaceResponse -> Rep CreateNamespaceResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateNamespaceResponse x -> CreateNamespaceResponse
$cfrom :: forall x. CreateNamespaceResponse -> Rep CreateNamespaceResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateNamespaceResponse' 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:
--
-- 'namespace', 'createNamespaceResponse_namespace' - The created namespace object.
--
-- 'httpStatus', 'createNamespaceResponse_httpStatus' - The response's http status code.
newCreateNamespaceResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateNamespaceResponse
newCreateNamespaceResponse :: Int -> CreateNamespaceResponse
newCreateNamespaceResponse Int
pHttpStatus_ =
  CreateNamespaceResponse'
    { $sel:namespace:CreateNamespaceResponse' :: Maybe Namespace
namespace =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateNamespaceResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The created namespace object.
createNamespaceResponse_namespace :: Lens.Lens' CreateNamespaceResponse (Prelude.Maybe Namespace)
createNamespaceResponse_namespace :: Lens' CreateNamespaceResponse (Maybe Namespace)
createNamespaceResponse_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamespaceResponse' {Maybe Namespace
namespace :: Maybe Namespace
$sel:namespace:CreateNamespaceResponse' :: CreateNamespaceResponse -> Maybe Namespace
namespace} -> Maybe Namespace
namespace) (\s :: CreateNamespaceResponse
s@CreateNamespaceResponse' {} Maybe Namespace
a -> CreateNamespaceResponse
s {$sel:namespace:CreateNamespaceResponse' :: Maybe Namespace
namespace = Maybe Namespace
a} :: CreateNamespaceResponse)

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

instance Prelude.NFData CreateNamespaceResponse where
  rnf :: CreateNamespaceResponse -> ()
rnf CreateNamespaceResponse' {Int
Maybe Namespace
httpStatus :: Int
namespace :: Maybe Namespace
$sel:httpStatus:CreateNamespaceResponse' :: CreateNamespaceResponse -> Int
$sel:namespace:CreateNamespaceResponse' :: CreateNamespaceResponse -> Maybe Namespace
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Namespace
namespace
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus