{-# 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.Lightsail.CreateRelationalDatabaseSnapshot
-- 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 snapshot of your database in Amazon Lightsail. You can use
-- snapshots for backups, to make copies of a database, and to save data
-- before deleting a database.
--
-- The @create relational database snapshot@ operation supports tag-based
-- access control via request tags. For more information, see the
-- <https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-controlling-access-using-tags Amazon Lightsail Developer Guide>.
module Amazonka.Lightsail.CreateRelationalDatabaseSnapshot
  ( -- * Creating a Request
    CreateRelationalDatabaseSnapshot (..),
    newCreateRelationalDatabaseSnapshot,

    -- * Request Lenses
    createRelationalDatabaseSnapshot_tags,
    createRelationalDatabaseSnapshot_relationalDatabaseName,
    createRelationalDatabaseSnapshot_relationalDatabaseSnapshotName,

    -- * Destructuring the Response
    CreateRelationalDatabaseSnapshotResponse (..),
    newCreateRelationalDatabaseSnapshotResponse,

    -- * Response Lenses
    createRelationalDatabaseSnapshotResponse_operations,
    createRelationalDatabaseSnapshotResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateRelationalDatabaseSnapshot' smart constructor.
data CreateRelationalDatabaseSnapshot = CreateRelationalDatabaseSnapshot'
  { -- | The tag keys and optional values to add to the resource during create.
    --
    -- Use the @TagResource@ action to tag a resource after it\'s created.
    CreateRelationalDatabaseSnapshot -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the database on which to base your new snapshot.
    CreateRelationalDatabaseSnapshot -> Text
relationalDatabaseName :: Prelude.Text,
    -- | The name for your new database snapshot.
    --
    -- Constraints:
    --
    -- -   Must contain from 2 to 255 alphanumeric characters, or hyphens.
    --
    -- -   The first and last character must be a letter or number.
    CreateRelationalDatabaseSnapshot -> Text
relationalDatabaseSnapshotName :: Prelude.Text
  }
  deriving (CreateRelationalDatabaseSnapshot
-> CreateRelationalDatabaseSnapshot -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRelationalDatabaseSnapshot
-> CreateRelationalDatabaseSnapshot -> Bool
$c/= :: CreateRelationalDatabaseSnapshot
-> CreateRelationalDatabaseSnapshot -> Bool
== :: CreateRelationalDatabaseSnapshot
-> CreateRelationalDatabaseSnapshot -> Bool
$c== :: CreateRelationalDatabaseSnapshot
-> CreateRelationalDatabaseSnapshot -> Bool
Prelude.Eq, ReadPrec [CreateRelationalDatabaseSnapshot]
ReadPrec CreateRelationalDatabaseSnapshot
Int -> ReadS CreateRelationalDatabaseSnapshot
ReadS [CreateRelationalDatabaseSnapshot]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRelationalDatabaseSnapshot]
$creadListPrec :: ReadPrec [CreateRelationalDatabaseSnapshot]
readPrec :: ReadPrec CreateRelationalDatabaseSnapshot
$creadPrec :: ReadPrec CreateRelationalDatabaseSnapshot
readList :: ReadS [CreateRelationalDatabaseSnapshot]
$creadList :: ReadS [CreateRelationalDatabaseSnapshot]
readsPrec :: Int -> ReadS CreateRelationalDatabaseSnapshot
$creadsPrec :: Int -> ReadS CreateRelationalDatabaseSnapshot
Prelude.Read, Int -> CreateRelationalDatabaseSnapshot -> ShowS
[CreateRelationalDatabaseSnapshot] -> ShowS
CreateRelationalDatabaseSnapshot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRelationalDatabaseSnapshot] -> ShowS
$cshowList :: [CreateRelationalDatabaseSnapshot] -> ShowS
show :: CreateRelationalDatabaseSnapshot -> String
$cshow :: CreateRelationalDatabaseSnapshot -> String
showsPrec :: Int -> CreateRelationalDatabaseSnapshot -> ShowS
$cshowsPrec :: Int -> CreateRelationalDatabaseSnapshot -> ShowS
Prelude.Show, forall x.
Rep CreateRelationalDatabaseSnapshot x
-> CreateRelationalDatabaseSnapshot
forall x.
CreateRelationalDatabaseSnapshot
-> Rep CreateRelationalDatabaseSnapshot x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateRelationalDatabaseSnapshot x
-> CreateRelationalDatabaseSnapshot
$cfrom :: forall x.
CreateRelationalDatabaseSnapshot
-> Rep CreateRelationalDatabaseSnapshot x
Prelude.Generic)

-- |
-- Create a value of 'CreateRelationalDatabaseSnapshot' 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', 'createRelationalDatabaseSnapshot_tags' - The tag keys and optional values to add to the resource during create.
--
-- Use the @TagResource@ action to tag a resource after it\'s created.
--
-- 'relationalDatabaseName', 'createRelationalDatabaseSnapshot_relationalDatabaseName' - The name of the database on which to base your new snapshot.
--
-- 'relationalDatabaseSnapshotName', 'createRelationalDatabaseSnapshot_relationalDatabaseSnapshotName' - The name for your new database snapshot.
--
-- Constraints:
--
-- -   Must contain from 2 to 255 alphanumeric characters, or hyphens.
--
-- -   The first and last character must be a letter or number.
newCreateRelationalDatabaseSnapshot ::
  -- | 'relationalDatabaseName'
  Prelude.Text ->
  -- | 'relationalDatabaseSnapshotName'
  Prelude.Text ->
  CreateRelationalDatabaseSnapshot
newCreateRelationalDatabaseSnapshot :: Text -> Text -> CreateRelationalDatabaseSnapshot
newCreateRelationalDatabaseSnapshot
  Text
pRelationalDatabaseName_
  Text
pRelationalDatabaseSnapshotName_ =
    CreateRelationalDatabaseSnapshot'
      { $sel:tags:CreateRelationalDatabaseSnapshot' :: Maybe [Tag]
tags =
          forall a. Maybe a
Prelude.Nothing,
        $sel:relationalDatabaseName:CreateRelationalDatabaseSnapshot' :: Text
relationalDatabaseName =
          Text
pRelationalDatabaseName_,
        $sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseSnapshot' :: Text
relationalDatabaseSnapshotName =
          Text
pRelationalDatabaseSnapshotName_
      }

-- | The tag keys and optional values to add to the resource during create.
--
-- Use the @TagResource@ action to tag a resource after it\'s created.
createRelationalDatabaseSnapshot_tags :: Lens.Lens' CreateRelationalDatabaseSnapshot (Prelude.Maybe [Tag])
createRelationalDatabaseSnapshot_tags :: Lens' CreateRelationalDatabaseSnapshot (Maybe [Tag])
createRelationalDatabaseSnapshot_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseSnapshot' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateRelationalDatabaseSnapshot
s@CreateRelationalDatabaseSnapshot' {} Maybe [Tag]
a -> CreateRelationalDatabaseSnapshot
s {$sel:tags:CreateRelationalDatabaseSnapshot' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateRelationalDatabaseSnapshot) 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 database on which to base your new snapshot.
createRelationalDatabaseSnapshot_relationalDatabaseName :: Lens.Lens' CreateRelationalDatabaseSnapshot Prelude.Text
createRelationalDatabaseSnapshot_relationalDatabaseName :: Lens' CreateRelationalDatabaseSnapshot Text
createRelationalDatabaseSnapshot_relationalDatabaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseSnapshot' {Text
relationalDatabaseName :: Text
$sel:relationalDatabaseName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
relationalDatabaseName} -> Text
relationalDatabaseName) (\s :: CreateRelationalDatabaseSnapshot
s@CreateRelationalDatabaseSnapshot' {} Text
a -> CreateRelationalDatabaseSnapshot
s {$sel:relationalDatabaseName:CreateRelationalDatabaseSnapshot' :: Text
relationalDatabaseName = Text
a} :: CreateRelationalDatabaseSnapshot)

-- | The name for your new database snapshot.
--
-- Constraints:
--
-- -   Must contain from 2 to 255 alphanumeric characters, or hyphens.
--
-- -   The first and last character must be a letter or number.
createRelationalDatabaseSnapshot_relationalDatabaseSnapshotName :: Lens.Lens' CreateRelationalDatabaseSnapshot Prelude.Text
createRelationalDatabaseSnapshot_relationalDatabaseSnapshotName :: Lens' CreateRelationalDatabaseSnapshot Text
createRelationalDatabaseSnapshot_relationalDatabaseSnapshotName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseSnapshot' {Text
relationalDatabaseSnapshotName :: Text
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
relationalDatabaseSnapshotName} -> Text
relationalDatabaseSnapshotName) (\s :: CreateRelationalDatabaseSnapshot
s@CreateRelationalDatabaseSnapshot' {} Text
a -> CreateRelationalDatabaseSnapshot
s {$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseSnapshot' :: Text
relationalDatabaseSnapshotName = Text
a} :: CreateRelationalDatabaseSnapshot)

instance
  Core.AWSRequest
    CreateRelationalDatabaseSnapshot
  where
  type
    AWSResponse CreateRelationalDatabaseSnapshot =
      CreateRelationalDatabaseSnapshotResponse
  request :: (Service -> Service)
-> CreateRelationalDatabaseSnapshot
-> Request CreateRelationalDatabaseSnapshot
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 CreateRelationalDatabaseSnapshot
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateRelationalDatabaseSnapshot)))
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 [Operation]
-> Int -> CreateRelationalDatabaseSnapshotResponse
CreateRelationalDatabaseSnapshotResponse'
            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
"operations" 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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance
  Prelude.Hashable
    CreateRelationalDatabaseSnapshot
  where
  hashWithSalt :: Int -> CreateRelationalDatabaseSnapshot -> Int
hashWithSalt
    Int
_salt
    CreateRelationalDatabaseSnapshot' {Maybe [Tag]
Text
relationalDatabaseSnapshotName :: Text
relationalDatabaseName :: Text
tags :: Maybe [Tag]
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
$sel:relationalDatabaseName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
$sel:tags:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Maybe [Tag]
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
relationalDatabaseName
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
relationalDatabaseSnapshotName

instance
  Prelude.NFData
    CreateRelationalDatabaseSnapshot
  where
  rnf :: CreateRelationalDatabaseSnapshot -> ()
rnf CreateRelationalDatabaseSnapshot' {Maybe [Tag]
Text
relationalDatabaseSnapshotName :: Text
relationalDatabaseName :: Text
tags :: Maybe [Tag]
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
$sel:relationalDatabaseName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
$sel:tags:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Maybe [Tag]
..} =
    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
relationalDatabaseName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
relationalDatabaseSnapshotName

instance
  Data.ToHeaders
    CreateRelationalDatabaseSnapshot
  where
  toHeaders :: CreateRelationalDatabaseSnapshot -> 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
"Lightsail_20161128.CreateRelationalDatabaseSnapshot" ::
                          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 CreateRelationalDatabaseSnapshot where
  toJSON :: CreateRelationalDatabaseSnapshot -> Value
toJSON CreateRelationalDatabaseSnapshot' {Maybe [Tag]
Text
relationalDatabaseSnapshotName :: Text
relationalDatabaseName :: Text
tags :: Maybe [Tag]
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
$sel:relationalDatabaseName:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Text
$sel:tags:CreateRelationalDatabaseSnapshot' :: CreateRelationalDatabaseSnapshot -> Maybe [Tag]
..} =
    [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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"relationalDatabaseName"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
relationalDatabaseName
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"relationalDatabaseSnapshotName"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
relationalDatabaseSnapshotName
              )
          ]
      )

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

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

-- | /See:/ 'newCreateRelationalDatabaseSnapshotResponse' smart constructor.
data CreateRelationalDatabaseSnapshotResponse = CreateRelationalDatabaseSnapshotResponse'
  { -- | An array of objects that describe the result of the action, such as the
    -- status of the request, the timestamp of the request, and the resources
    -- affected by the request.
    CreateRelationalDatabaseSnapshotResponse -> Maybe [Operation]
operations :: Prelude.Maybe [Operation],
    -- | The response's http status code.
    CreateRelationalDatabaseSnapshotResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateRelationalDatabaseSnapshotResponse
-> CreateRelationalDatabaseSnapshotResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRelationalDatabaseSnapshotResponse
-> CreateRelationalDatabaseSnapshotResponse -> Bool
$c/= :: CreateRelationalDatabaseSnapshotResponse
-> CreateRelationalDatabaseSnapshotResponse -> Bool
== :: CreateRelationalDatabaseSnapshotResponse
-> CreateRelationalDatabaseSnapshotResponse -> Bool
$c== :: CreateRelationalDatabaseSnapshotResponse
-> CreateRelationalDatabaseSnapshotResponse -> Bool
Prelude.Eq, ReadPrec [CreateRelationalDatabaseSnapshotResponse]
ReadPrec CreateRelationalDatabaseSnapshotResponse
Int -> ReadS CreateRelationalDatabaseSnapshotResponse
ReadS [CreateRelationalDatabaseSnapshotResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRelationalDatabaseSnapshotResponse]
$creadListPrec :: ReadPrec [CreateRelationalDatabaseSnapshotResponse]
readPrec :: ReadPrec CreateRelationalDatabaseSnapshotResponse
$creadPrec :: ReadPrec CreateRelationalDatabaseSnapshotResponse
readList :: ReadS [CreateRelationalDatabaseSnapshotResponse]
$creadList :: ReadS [CreateRelationalDatabaseSnapshotResponse]
readsPrec :: Int -> ReadS CreateRelationalDatabaseSnapshotResponse
$creadsPrec :: Int -> ReadS CreateRelationalDatabaseSnapshotResponse
Prelude.Read, Int -> CreateRelationalDatabaseSnapshotResponse -> ShowS
[CreateRelationalDatabaseSnapshotResponse] -> ShowS
CreateRelationalDatabaseSnapshotResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRelationalDatabaseSnapshotResponse] -> ShowS
$cshowList :: [CreateRelationalDatabaseSnapshotResponse] -> ShowS
show :: CreateRelationalDatabaseSnapshotResponse -> String
$cshow :: CreateRelationalDatabaseSnapshotResponse -> String
showsPrec :: Int -> CreateRelationalDatabaseSnapshotResponse -> ShowS
$cshowsPrec :: Int -> CreateRelationalDatabaseSnapshotResponse -> ShowS
Prelude.Show, forall x.
Rep CreateRelationalDatabaseSnapshotResponse x
-> CreateRelationalDatabaseSnapshotResponse
forall x.
CreateRelationalDatabaseSnapshotResponse
-> Rep CreateRelationalDatabaseSnapshotResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateRelationalDatabaseSnapshotResponse x
-> CreateRelationalDatabaseSnapshotResponse
$cfrom :: forall x.
CreateRelationalDatabaseSnapshotResponse
-> Rep CreateRelationalDatabaseSnapshotResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateRelationalDatabaseSnapshotResponse' 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:
--
-- 'operations', 'createRelationalDatabaseSnapshotResponse_operations' - An array of objects that describe the result of the action, such as the
-- status of the request, the timestamp of the request, and the resources
-- affected by the request.
--
-- 'httpStatus', 'createRelationalDatabaseSnapshotResponse_httpStatus' - The response's http status code.
newCreateRelationalDatabaseSnapshotResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateRelationalDatabaseSnapshotResponse
newCreateRelationalDatabaseSnapshotResponse :: Int -> CreateRelationalDatabaseSnapshotResponse
newCreateRelationalDatabaseSnapshotResponse
  Int
pHttpStatus_ =
    CreateRelationalDatabaseSnapshotResponse'
      { $sel:operations:CreateRelationalDatabaseSnapshotResponse' :: Maybe [Operation]
operations =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateRelationalDatabaseSnapshotResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | An array of objects that describe the result of the action, such as the
-- status of the request, the timestamp of the request, and the resources
-- affected by the request.
createRelationalDatabaseSnapshotResponse_operations :: Lens.Lens' CreateRelationalDatabaseSnapshotResponse (Prelude.Maybe [Operation])
createRelationalDatabaseSnapshotResponse_operations :: Lens' CreateRelationalDatabaseSnapshotResponse (Maybe [Operation])
createRelationalDatabaseSnapshotResponse_operations = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseSnapshotResponse' {Maybe [Operation]
operations :: Maybe [Operation]
$sel:operations:CreateRelationalDatabaseSnapshotResponse' :: CreateRelationalDatabaseSnapshotResponse -> Maybe [Operation]
operations} -> Maybe [Operation]
operations) (\s :: CreateRelationalDatabaseSnapshotResponse
s@CreateRelationalDatabaseSnapshotResponse' {} Maybe [Operation]
a -> CreateRelationalDatabaseSnapshotResponse
s {$sel:operations:CreateRelationalDatabaseSnapshotResponse' :: Maybe [Operation]
operations = Maybe [Operation]
a} :: CreateRelationalDatabaseSnapshotResponse) 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 response's http status code.
createRelationalDatabaseSnapshotResponse_httpStatus :: Lens.Lens' CreateRelationalDatabaseSnapshotResponse Prelude.Int
createRelationalDatabaseSnapshotResponse_httpStatus :: Lens' CreateRelationalDatabaseSnapshotResponse Int
createRelationalDatabaseSnapshotResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseSnapshotResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateRelationalDatabaseSnapshotResponse' :: CreateRelationalDatabaseSnapshotResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateRelationalDatabaseSnapshotResponse
s@CreateRelationalDatabaseSnapshotResponse' {} Int
a -> CreateRelationalDatabaseSnapshotResponse
s {$sel:httpStatus:CreateRelationalDatabaseSnapshotResponse' :: Int
httpStatus = Int
a} :: CreateRelationalDatabaseSnapshotResponse)

instance
  Prelude.NFData
    CreateRelationalDatabaseSnapshotResponse
  where
  rnf :: CreateRelationalDatabaseSnapshotResponse -> ()
rnf CreateRelationalDatabaseSnapshotResponse' {Int
Maybe [Operation]
httpStatus :: Int
operations :: Maybe [Operation]
$sel:httpStatus:CreateRelationalDatabaseSnapshotResponse' :: CreateRelationalDatabaseSnapshotResponse -> Int
$sel:operations:CreateRelationalDatabaseSnapshotResponse' :: CreateRelationalDatabaseSnapshotResponse -> Maybe [Operation]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Operation]
operations
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus