{-# 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.Omics.CreateSequenceStore
-- 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 sequence store.
module Amazonka.Omics.CreateSequenceStore
  ( -- * Creating a Request
    CreateSequenceStore (..),
    newCreateSequenceStore,

    -- * Request Lenses
    createSequenceStore_clientToken,
    createSequenceStore_description,
    createSequenceStore_sseConfig,
    createSequenceStore_tags,
    createSequenceStore_name,

    -- * Destructuring the Response
    CreateSequenceStoreResponse (..),
    newCreateSequenceStoreResponse,

    -- * Response Lenses
    createSequenceStoreResponse_description,
    createSequenceStoreResponse_name,
    createSequenceStoreResponse_sseConfig,
    createSequenceStoreResponse_httpStatus,
    createSequenceStoreResponse_arn,
    createSequenceStoreResponse_creationTime,
    createSequenceStoreResponse_id,
  )
where

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

-- | /See:/ 'newCreateSequenceStore' smart constructor.
data CreateSequenceStore = CreateSequenceStore'
  { -- | To ensure that requests don\'t run multiple times, specify a unique
    -- token for each request.
    CreateSequenceStore -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | A description for the store.
    CreateSequenceStore -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Server-side encryption (SSE) settings for the store.
    CreateSequenceStore -> Maybe SseConfig
sseConfig :: Prelude.Maybe SseConfig,
    -- | Tags for the store.
    CreateSequenceStore -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A name for the store.
    CreateSequenceStore -> Text
name :: Prelude.Text
  }
  deriving (CreateSequenceStore -> CreateSequenceStore -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSequenceStore -> CreateSequenceStore -> Bool
$c/= :: CreateSequenceStore -> CreateSequenceStore -> Bool
== :: CreateSequenceStore -> CreateSequenceStore -> Bool
$c== :: CreateSequenceStore -> CreateSequenceStore -> Bool
Prelude.Eq, ReadPrec [CreateSequenceStore]
ReadPrec CreateSequenceStore
Int -> ReadS CreateSequenceStore
ReadS [CreateSequenceStore]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSequenceStore]
$creadListPrec :: ReadPrec [CreateSequenceStore]
readPrec :: ReadPrec CreateSequenceStore
$creadPrec :: ReadPrec CreateSequenceStore
readList :: ReadS [CreateSequenceStore]
$creadList :: ReadS [CreateSequenceStore]
readsPrec :: Int -> ReadS CreateSequenceStore
$creadsPrec :: Int -> ReadS CreateSequenceStore
Prelude.Read, Int -> CreateSequenceStore -> ShowS
[CreateSequenceStore] -> ShowS
CreateSequenceStore -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSequenceStore] -> ShowS
$cshowList :: [CreateSequenceStore] -> ShowS
show :: CreateSequenceStore -> String
$cshow :: CreateSequenceStore -> String
showsPrec :: Int -> CreateSequenceStore -> ShowS
$cshowsPrec :: Int -> CreateSequenceStore -> ShowS
Prelude.Show, forall x. Rep CreateSequenceStore x -> CreateSequenceStore
forall x. CreateSequenceStore -> Rep CreateSequenceStore x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateSequenceStore x -> CreateSequenceStore
$cfrom :: forall x. CreateSequenceStore -> Rep CreateSequenceStore x
Prelude.Generic)

-- |
-- Create a value of 'CreateSequenceStore' 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:
--
-- 'clientToken', 'createSequenceStore_clientToken' - To ensure that requests don\'t run multiple times, specify a unique
-- token for each request.
--
-- 'description', 'createSequenceStore_description' - A description for the store.
--
-- 'sseConfig', 'createSequenceStore_sseConfig' - Server-side encryption (SSE) settings for the store.
--
-- 'tags', 'createSequenceStore_tags' - Tags for the store.
--
-- 'name', 'createSequenceStore_name' - A name for the store.
newCreateSequenceStore ::
  -- | 'name'
  Prelude.Text ->
  CreateSequenceStore
newCreateSequenceStore :: Text -> CreateSequenceStore
newCreateSequenceStore Text
pName_ =
  CreateSequenceStore'
    { $sel:clientToken:CreateSequenceStore' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateSequenceStore' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:sseConfig:CreateSequenceStore' :: Maybe SseConfig
sseConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateSequenceStore' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateSequenceStore' :: Text
name = Text
pName_
    }

-- | To ensure that requests don\'t run multiple times, specify a unique
-- token for each request.
createSequenceStore_clientToken :: Lens.Lens' CreateSequenceStore (Prelude.Maybe Prelude.Text)
createSequenceStore_clientToken :: Lens' CreateSequenceStore (Maybe Text)
createSequenceStore_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStore' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateSequenceStore
s@CreateSequenceStore' {} Maybe Text
a -> CreateSequenceStore
s {$sel:clientToken:CreateSequenceStore' :: Maybe Text
clientToken = Maybe Text
a} :: CreateSequenceStore)

-- | A description for the store.
createSequenceStore_description :: Lens.Lens' CreateSequenceStore (Prelude.Maybe Prelude.Text)
createSequenceStore_description :: Lens' CreateSequenceStore (Maybe Text)
createSequenceStore_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStore' {Maybe Text
description :: Maybe Text
$sel:description:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateSequenceStore
s@CreateSequenceStore' {} Maybe Text
a -> CreateSequenceStore
s {$sel:description:CreateSequenceStore' :: Maybe Text
description = Maybe Text
a} :: CreateSequenceStore)

-- | Server-side encryption (SSE) settings for the store.
createSequenceStore_sseConfig :: Lens.Lens' CreateSequenceStore (Prelude.Maybe SseConfig)
createSequenceStore_sseConfig :: Lens' CreateSequenceStore (Maybe SseConfig)
createSequenceStore_sseConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStore' {Maybe SseConfig
sseConfig :: Maybe SseConfig
$sel:sseConfig:CreateSequenceStore' :: CreateSequenceStore -> Maybe SseConfig
sseConfig} -> Maybe SseConfig
sseConfig) (\s :: CreateSequenceStore
s@CreateSequenceStore' {} Maybe SseConfig
a -> CreateSequenceStore
s {$sel:sseConfig:CreateSequenceStore' :: Maybe SseConfig
sseConfig = Maybe SseConfig
a} :: CreateSequenceStore)

-- | Tags for the store.
createSequenceStore_tags :: Lens.Lens' CreateSequenceStore (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createSequenceStore_tags :: Lens' CreateSequenceStore (Maybe (HashMap Text Text))
createSequenceStore_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStore' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateSequenceStore' :: CreateSequenceStore -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateSequenceStore
s@CreateSequenceStore' {} Maybe (HashMap Text Text)
a -> CreateSequenceStore
s {$sel:tags:CreateSequenceStore' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateSequenceStore) 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 name for the store.
createSequenceStore_name :: Lens.Lens' CreateSequenceStore Prelude.Text
createSequenceStore_name :: Lens' CreateSequenceStore Text
createSequenceStore_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStore' {Text
name :: Text
$sel:name:CreateSequenceStore' :: CreateSequenceStore -> Text
name} -> Text
name) (\s :: CreateSequenceStore
s@CreateSequenceStore' {} Text
a -> CreateSequenceStore
s {$sel:name:CreateSequenceStore' :: Text
name = Text
a} :: CreateSequenceStore)

instance Core.AWSRequest CreateSequenceStore where
  type
    AWSResponse CreateSequenceStore =
      CreateSequenceStoreResponse
  request :: (Service -> Service)
-> CreateSequenceStore -> Request CreateSequenceStore
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 CreateSequenceStore
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateSequenceStore)))
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 SseConfig
-> Int
-> Text
-> ISO8601
-> Text
-> CreateSequenceStoreResponse
CreateSequenceStoreResponse'
            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
"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
"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
"sseConfig")
            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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String 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 a
Data..:> Key
"creationTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"id")
      )

instance Prelude.Hashable CreateSequenceStore where
  hashWithSalt :: Int -> CreateSequenceStore -> Int
hashWithSalt Int
_salt CreateSequenceStore' {Maybe Text
Maybe (HashMap Text Text)
Maybe SseConfig
Text
name :: Text
tags :: Maybe (HashMap Text Text)
sseConfig :: Maybe SseConfig
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateSequenceStore' :: CreateSequenceStore -> Text
$sel:tags:CreateSequenceStore' :: CreateSequenceStore -> Maybe (HashMap Text Text)
$sel:sseConfig:CreateSequenceStore' :: CreateSequenceStore -> Maybe SseConfig
$sel:description:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
$sel:clientToken:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SseConfig
sseConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateSequenceStore where
  rnf :: CreateSequenceStore -> ()
rnf CreateSequenceStore' {Maybe Text
Maybe (HashMap Text Text)
Maybe SseConfig
Text
name :: Text
tags :: Maybe (HashMap Text Text)
sseConfig :: Maybe SseConfig
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateSequenceStore' :: CreateSequenceStore -> Text
$sel:tags:CreateSequenceStore' :: CreateSequenceStore -> Maybe (HashMap Text Text)
$sel:sseConfig:CreateSequenceStore' :: CreateSequenceStore -> Maybe SseConfig
$sel:description:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
$sel:clientToken:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      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 SseConfig
sseConfig
      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 Text
name

instance Data.ToHeaders CreateSequenceStore where
  toHeaders :: CreateSequenceStore -> 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 CreateSequenceStore where
  toJSON :: CreateSequenceStore -> Value
toJSON CreateSequenceStore' {Maybe Text
Maybe (HashMap Text Text)
Maybe SseConfig
Text
name :: Text
tags :: Maybe (HashMap Text Text)
sseConfig :: Maybe SseConfig
description :: Maybe Text
clientToken :: Maybe Text
$sel:name:CreateSequenceStore' :: CreateSequenceStore -> Text
$sel:tags:CreateSequenceStore' :: CreateSequenceStore -> Maybe (HashMap Text Text)
$sel:sseConfig:CreateSequenceStore' :: CreateSequenceStore -> Maybe SseConfig
$sel:description:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
$sel:clientToken:CreateSequenceStore' :: CreateSequenceStore -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientToken" 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
clientToken,
            (Key
"description" 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
description,
            (Key
"sseConfig" 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 SseConfig
sseConfig,
            (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
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

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

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

-- | /See:/ 'newCreateSequenceStoreResponse' smart constructor.
data CreateSequenceStoreResponse = CreateSequenceStoreResponse'
  { -- | The store\'s description.
    CreateSequenceStoreResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The store\'s name.
    CreateSequenceStoreResponse -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The store\'s SSE settings.
    CreateSequenceStoreResponse -> Maybe SseConfig
sseConfig :: Prelude.Maybe SseConfig,
    -- | The response's http status code.
    CreateSequenceStoreResponse -> Int
httpStatus :: Prelude.Int,
    -- | The store\'s ARN.
    CreateSequenceStoreResponse -> Text
arn :: Prelude.Text,
    -- | When the store was created.
    CreateSequenceStoreResponse -> ISO8601
creationTime :: Data.ISO8601,
    -- | The store\'s ID.
    CreateSequenceStoreResponse -> Text
id :: Prelude.Text
  }
  deriving (CreateSequenceStoreResponse -> CreateSequenceStoreResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSequenceStoreResponse -> CreateSequenceStoreResponse -> Bool
$c/= :: CreateSequenceStoreResponse -> CreateSequenceStoreResponse -> Bool
== :: CreateSequenceStoreResponse -> CreateSequenceStoreResponse -> Bool
$c== :: CreateSequenceStoreResponse -> CreateSequenceStoreResponse -> Bool
Prelude.Eq, ReadPrec [CreateSequenceStoreResponse]
ReadPrec CreateSequenceStoreResponse
Int -> ReadS CreateSequenceStoreResponse
ReadS [CreateSequenceStoreResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSequenceStoreResponse]
$creadListPrec :: ReadPrec [CreateSequenceStoreResponse]
readPrec :: ReadPrec CreateSequenceStoreResponse
$creadPrec :: ReadPrec CreateSequenceStoreResponse
readList :: ReadS [CreateSequenceStoreResponse]
$creadList :: ReadS [CreateSequenceStoreResponse]
readsPrec :: Int -> ReadS CreateSequenceStoreResponse
$creadsPrec :: Int -> ReadS CreateSequenceStoreResponse
Prelude.Read, Int -> CreateSequenceStoreResponse -> ShowS
[CreateSequenceStoreResponse] -> ShowS
CreateSequenceStoreResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSequenceStoreResponse] -> ShowS
$cshowList :: [CreateSequenceStoreResponse] -> ShowS
show :: CreateSequenceStoreResponse -> String
$cshow :: CreateSequenceStoreResponse -> String
showsPrec :: Int -> CreateSequenceStoreResponse -> ShowS
$cshowsPrec :: Int -> CreateSequenceStoreResponse -> ShowS
Prelude.Show, forall x.
Rep CreateSequenceStoreResponse x -> CreateSequenceStoreResponse
forall x.
CreateSequenceStoreResponse -> Rep CreateSequenceStoreResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateSequenceStoreResponse x -> CreateSequenceStoreResponse
$cfrom :: forall x.
CreateSequenceStoreResponse -> Rep CreateSequenceStoreResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateSequenceStoreResponse' 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:
--
-- 'description', 'createSequenceStoreResponse_description' - The store\'s description.
--
-- 'name', 'createSequenceStoreResponse_name' - The store\'s name.
--
-- 'sseConfig', 'createSequenceStoreResponse_sseConfig' - The store\'s SSE settings.
--
-- 'httpStatus', 'createSequenceStoreResponse_httpStatus' - The response's http status code.
--
-- 'arn', 'createSequenceStoreResponse_arn' - The store\'s ARN.
--
-- 'creationTime', 'createSequenceStoreResponse_creationTime' - When the store was created.
--
-- 'id', 'createSequenceStoreResponse_id' - The store\'s ID.
newCreateSequenceStoreResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'arn'
  Prelude.Text ->
  -- | 'creationTime'
  Prelude.UTCTime ->
  -- | 'id'
  Prelude.Text ->
  CreateSequenceStoreResponse
newCreateSequenceStoreResponse :: Int -> Text -> UTCTime -> Text -> CreateSequenceStoreResponse
newCreateSequenceStoreResponse
  Int
pHttpStatus_
  Text
pArn_
  UTCTime
pCreationTime_
  Text
pId_ =
    CreateSequenceStoreResponse'
      { $sel:description:CreateSequenceStoreResponse' :: Maybe Text
description =
          forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateSequenceStoreResponse' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
        $sel:sseConfig:CreateSequenceStoreResponse' :: Maybe SseConfig
sseConfig = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateSequenceStoreResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:arn:CreateSequenceStoreResponse' :: Text
arn = Text
pArn_,
        $sel:creationTime:CreateSequenceStoreResponse' :: ISO8601
creationTime =
          forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pCreationTime_,
        $sel:id:CreateSequenceStoreResponse' :: Text
id = Text
pId_
      }

-- | The store\'s description.
createSequenceStoreResponse_description :: Lens.Lens' CreateSequenceStoreResponse (Prelude.Maybe Prelude.Text)
createSequenceStoreResponse_description :: Lens' CreateSequenceStoreResponse (Maybe Text)
createSequenceStoreResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStoreResponse' {Maybe Text
description :: Maybe Text
$sel:description:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateSequenceStoreResponse
s@CreateSequenceStoreResponse' {} Maybe Text
a -> CreateSequenceStoreResponse
s {$sel:description:CreateSequenceStoreResponse' :: Maybe Text
description = Maybe Text
a} :: CreateSequenceStoreResponse)

-- | The store\'s name.
createSequenceStoreResponse_name :: Lens.Lens' CreateSequenceStoreResponse (Prelude.Maybe Prelude.Text)
createSequenceStoreResponse_name :: Lens' CreateSequenceStoreResponse (Maybe Text)
createSequenceStoreResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStoreResponse' {Maybe Text
name :: Maybe Text
$sel:name:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Maybe Text
name} -> Maybe Text
name) (\s :: CreateSequenceStoreResponse
s@CreateSequenceStoreResponse' {} Maybe Text
a -> CreateSequenceStoreResponse
s {$sel:name:CreateSequenceStoreResponse' :: Maybe Text
name = Maybe Text
a} :: CreateSequenceStoreResponse)

-- | The store\'s SSE settings.
createSequenceStoreResponse_sseConfig :: Lens.Lens' CreateSequenceStoreResponse (Prelude.Maybe SseConfig)
createSequenceStoreResponse_sseConfig :: Lens' CreateSequenceStoreResponse (Maybe SseConfig)
createSequenceStoreResponse_sseConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStoreResponse' {Maybe SseConfig
sseConfig :: Maybe SseConfig
$sel:sseConfig:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Maybe SseConfig
sseConfig} -> Maybe SseConfig
sseConfig) (\s :: CreateSequenceStoreResponse
s@CreateSequenceStoreResponse' {} Maybe SseConfig
a -> CreateSequenceStoreResponse
s {$sel:sseConfig:CreateSequenceStoreResponse' :: Maybe SseConfig
sseConfig = Maybe SseConfig
a} :: CreateSequenceStoreResponse)

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

-- | The store\'s ARN.
createSequenceStoreResponse_arn :: Lens.Lens' CreateSequenceStoreResponse Prelude.Text
createSequenceStoreResponse_arn :: Lens' CreateSequenceStoreResponse Text
createSequenceStoreResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStoreResponse' {Text
arn :: Text
$sel:arn:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Text
arn} -> Text
arn) (\s :: CreateSequenceStoreResponse
s@CreateSequenceStoreResponse' {} Text
a -> CreateSequenceStoreResponse
s {$sel:arn:CreateSequenceStoreResponse' :: Text
arn = Text
a} :: CreateSequenceStoreResponse)

-- | When the store was created.
createSequenceStoreResponse_creationTime :: Lens.Lens' CreateSequenceStoreResponse Prelude.UTCTime
createSequenceStoreResponse_creationTime :: Lens' CreateSequenceStoreResponse UTCTime
createSequenceStoreResponse_creationTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStoreResponse' {ISO8601
creationTime :: ISO8601
$sel:creationTime:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> ISO8601
creationTime} -> ISO8601
creationTime) (\s :: CreateSequenceStoreResponse
s@CreateSequenceStoreResponse' {} ISO8601
a -> CreateSequenceStoreResponse
s {$sel:creationTime:CreateSequenceStoreResponse' :: ISO8601
creationTime = ISO8601
a} :: CreateSequenceStoreResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The store\'s ID.
createSequenceStoreResponse_id :: Lens.Lens' CreateSequenceStoreResponse Prelude.Text
createSequenceStoreResponse_id :: Lens' CreateSequenceStoreResponse Text
createSequenceStoreResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSequenceStoreResponse' {Text
id :: Text
$sel:id:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Text
id} -> Text
id) (\s :: CreateSequenceStoreResponse
s@CreateSequenceStoreResponse' {} Text
a -> CreateSequenceStoreResponse
s {$sel:id:CreateSequenceStoreResponse' :: Text
id = Text
a} :: CreateSequenceStoreResponse)

instance Prelude.NFData CreateSequenceStoreResponse where
  rnf :: CreateSequenceStoreResponse -> ()
rnf CreateSequenceStoreResponse' {Int
Maybe Text
Maybe SseConfig
Text
ISO8601
id :: Text
creationTime :: ISO8601
arn :: Text
httpStatus :: Int
sseConfig :: Maybe SseConfig
name :: Maybe Text
description :: Maybe Text
$sel:id:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Text
$sel:creationTime:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> ISO8601
$sel:arn:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Text
$sel:httpStatus:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Int
$sel:sseConfig:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Maybe SseConfig
$sel:name:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Maybe Text
$sel:description:CreateSequenceStoreResponse' :: CreateSequenceStoreResponse -> Maybe Text
..} =
    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
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SseConfig
sseConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ISO8601
creationTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id