{-# 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.CreateRelationalDatabaseFromSnapshot
-- 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 new database from an existing database snapshot in Amazon
-- Lightsail.
--
-- You can create a new database from a snapshot in if something goes wrong
-- with your original database, or to change it to a different plan, such
-- as a high availability or standard plan.
--
-- The @create relational database from snapshot@ operation supports
-- tag-based access control via request tags and resource tags applied to
-- the resource identified by relationalDatabaseSnapshotName. 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.CreateRelationalDatabaseFromSnapshot
  ( -- * Creating a Request
    CreateRelationalDatabaseFromSnapshot (..),
    newCreateRelationalDatabaseFromSnapshot,

    -- * Request Lenses
    createRelationalDatabaseFromSnapshot_availabilityZone,
    createRelationalDatabaseFromSnapshot_publiclyAccessible,
    createRelationalDatabaseFromSnapshot_relationalDatabaseBundleId,
    createRelationalDatabaseFromSnapshot_relationalDatabaseSnapshotName,
    createRelationalDatabaseFromSnapshot_restoreTime,
    createRelationalDatabaseFromSnapshot_sourceRelationalDatabaseName,
    createRelationalDatabaseFromSnapshot_tags,
    createRelationalDatabaseFromSnapshot_useLatestRestorableTime,
    createRelationalDatabaseFromSnapshot_relationalDatabaseName,

    -- * Destructuring the Response
    CreateRelationalDatabaseFromSnapshotResponse (..),
    newCreateRelationalDatabaseFromSnapshotResponse,

    -- * Response Lenses
    createRelationalDatabaseFromSnapshotResponse_operations,
    createRelationalDatabaseFromSnapshotResponse_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:/ 'newCreateRelationalDatabaseFromSnapshot' smart constructor.
data CreateRelationalDatabaseFromSnapshot = CreateRelationalDatabaseFromSnapshot'
  { -- | The Availability Zone in which to create your new database. Use the
    -- @us-east-2a@ case-sensitive format.
    --
    -- You can get a list of Availability Zones by using the @get regions@
    -- operation. Be sure to add the
    -- @include relational database Availability Zones@ parameter to your
    -- request.
    CreateRelationalDatabaseFromSnapshot -> Maybe Text
availabilityZone :: Prelude.Maybe Prelude.Text,
    -- | Specifies the accessibility options for your new database. A value of
    -- @true@ specifies a database that is available to resources outside of
    -- your Lightsail account. A value of @false@ specifies a database that is
    -- available only to your Lightsail resources in the same region as your
    -- database.
    CreateRelationalDatabaseFromSnapshot -> Maybe Bool
publiclyAccessible :: Prelude.Maybe Prelude.Bool,
    -- | The bundle ID for your new database. A bundle describes the performance
    -- specifications for your database.
    --
    -- You can get a list of database bundle IDs by using the
    -- @get relational database bundles@ operation.
    --
    -- When creating a new database from a snapshot, you cannot choose a bundle
    -- that is smaller than the bundle of the source database.
    CreateRelationalDatabaseFromSnapshot -> Maybe Text
relationalDatabaseBundleId :: Prelude.Maybe Prelude.Text,
    -- | The name of the database snapshot from which to create your new
    -- database.
    CreateRelationalDatabaseFromSnapshot -> Maybe Text
relationalDatabaseSnapshotName :: Prelude.Maybe Prelude.Text,
    -- | The date and time to restore your database from.
    --
    -- Constraints:
    --
    -- -   Must be before the latest restorable time for the database.
    --
    -- -   Cannot be specified if the @use latest restorable time@ parameter is
    --     @true@.
    --
    -- -   Specified in Coordinated Universal Time (UTC).
    --
    -- -   Specified in the Unix time format.
    --
    --     For example, if you wish to use a restore time of October 1, 2018,
    --     at 8 PM UTC, then you input @1538424000@ as the restore time.
    CreateRelationalDatabaseFromSnapshot -> Maybe POSIX
restoreTime :: Prelude.Maybe Data.POSIX,
    -- | The name of the source database.
    CreateRelationalDatabaseFromSnapshot -> Maybe Text
sourceRelationalDatabaseName :: Prelude.Maybe Prelude.Text,
    -- | 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.
    CreateRelationalDatabaseFromSnapshot -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | Specifies whether your database is restored from the latest backup time.
    -- A value of @true@ restores from the latest backup time.
    --
    -- Default: @false@
    --
    -- Constraints: Cannot be specified if the @restore time@ parameter is
    -- provided.
    CreateRelationalDatabaseFromSnapshot -> Maybe Bool
useLatestRestorableTime :: Prelude.Maybe Prelude.Bool,
    -- | The name to use for your new Lightsail database resource.
    --
    -- Constraints:
    --
    -- -   Must contain from 2 to 255 alphanumeric characters, or hyphens.
    --
    -- -   The first and last character must be a letter or number.
    CreateRelationalDatabaseFromSnapshot -> Text
relationalDatabaseName :: Prelude.Text
  }
  deriving (CreateRelationalDatabaseFromSnapshot
-> CreateRelationalDatabaseFromSnapshot -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRelationalDatabaseFromSnapshot
-> CreateRelationalDatabaseFromSnapshot -> Bool
$c/= :: CreateRelationalDatabaseFromSnapshot
-> CreateRelationalDatabaseFromSnapshot -> Bool
== :: CreateRelationalDatabaseFromSnapshot
-> CreateRelationalDatabaseFromSnapshot -> Bool
$c== :: CreateRelationalDatabaseFromSnapshot
-> CreateRelationalDatabaseFromSnapshot -> Bool
Prelude.Eq, ReadPrec [CreateRelationalDatabaseFromSnapshot]
ReadPrec CreateRelationalDatabaseFromSnapshot
Int -> ReadS CreateRelationalDatabaseFromSnapshot
ReadS [CreateRelationalDatabaseFromSnapshot]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRelationalDatabaseFromSnapshot]
$creadListPrec :: ReadPrec [CreateRelationalDatabaseFromSnapshot]
readPrec :: ReadPrec CreateRelationalDatabaseFromSnapshot
$creadPrec :: ReadPrec CreateRelationalDatabaseFromSnapshot
readList :: ReadS [CreateRelationalDatabaseFromSnapshot]
$creadList :: ReadS [CreateRelationalDatabaseFromSnapshot]
readsPrec :: Int -> ReadS CreateRelationalDatabaseFromSnapshot
$creadsPrec :: Int -> ReadS CreateRelationalDatabaseFromSnapshot
Prelude.Read, Int -> CreateRelationalDatabaseFromSnapshot -> ShowS
[CreateRelationalDatabaseFromSnapshot] -> ShowS
CreateRelationalDatabaseFromSnapshot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRelationalDatabaseFromSnapshot] -> ShowS
$cshowList :: [CreateRelationalDatabaseFromSnapshot] -> ShowS
show :: CreateRelationalDatabaseFromSnapshot -> String
$cshow :: CreateRelationalDatabaseFromSnapshot -> String
showsPrec :: Int -> CreateRelationalDatabaseFromSnapshot -> ShowS
$cshowsPrec :: Int -> CreateRelationalDatabaseFromSnapshot -> ShowS
Prelude.Show, forall x.
Rep CreateRelationalDatabaseFromSnapshot x
-> CreateRelationalDatabaseFromSnapshot
forall x.
CreateRelationalDatabaseFromSnapshot
-> Rep CreateRelationalDatabaseFromSnapshot x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateRelationalDatabaseFromSnapshot x
-> CreateRelationalDatabaseFromSnapshot
$cfrom :: forall x.
CreateRelationalDatabaseFromSnapshot
-> Rep CreateRelationalDatabaseFromSnapshot x
Prelude.Generic)

-- |
-- Create a value of 'CreateRelationalDatabaseFromSnapshot' 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:
--
-- 'availabilityZone', 'createRelationalDatabaseFromSnapshot_availabilityZone' - The Availability Zone in which to create your new database. Use the
-- @us-east-2a@ case-sensitive format.
--
-- You can get a list of Availability Zones by using the @get regions@
-- operation. Be sure to add the
-- @include relational database Availability Zones@ parameter to your
-- request.
--
-- 'publiclyAccessible', 'createRelationalDatabaseFromSnapshot_publiclyAccessible' - Specifies the accessibility options for your new database. A value of
-- @true@ specifies a database that is available to resources outside of
-- your Lightsail account. A value of @false@ specifies a database that is
-- available only to your Lightsail resources in the same region as your
-- database.
--
-- 'relationalDatabaseBundleId', 'createRelationalDatabaseFromSnapshot_relationalDatabaseBundleId' - The bundle ID for your new database. A bundle describes the performance
-- specifications for your database.
--
-- You can get a list of database bundle IDs by using the
-- @get relational database bundles@ operation.
--
-- When creating a new database from a snapshot, you cannot choose a bundle
-- that is smaller than the bundle of the source database.
--
-- 'relationalDatabaseSnapshotName', 'createRelationalDatabaseFromSnapshot_relationalDatabaseSnapshotName' - The name of the database snapshot from which to create your new
-- database.
--
-- 'restoreTime', 'createRelationalDatabaseFromSnapshot_restoreTime' - The date and time to restore your database from.
--
-- Constraints:
--
-- -   Must be before the latest restorable time for the database.
--
-- -   Cannot be specified if the @use latest restorable time@ parameter is
--     @true@.
--
-- -   Specified in Coordinated Universal Time (UTC).
--
-- -   Specified in the Unix time format.
--
--     For example, if you wish to use a restore time of October 1, 2018,
--     at 8 PM UTC, then you input @1538424000@ as the restore time.
--
-- 'sourceRelationalDatabaseName', 'createRelationalDatabaseFromSnapshot_sourceRelationalDatabaseName' - The name of the source database.
--
-- 'tags', 'createRelationalDatabaseFromSnapshot_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.
--
-- 'useLatestRestorableTime', 'createRelationalDatabaseFromSnapshot_useLatestRestorableTime' - Specifies whether your database is restored from the latest backup time.
-- A value of @true@ restores from the latest backup time.
--
-- Default: @false@
--
-- Constraints: Cannot be specified if the @restore time@ parameter is
-- provided.
--
-- 'relationalDatabaseName', 'createRelationalDatabaseFromSnapshot_relationalDatabaseName' - The name to use for your new Lightsail database resource.
--
-- Constraints:
--
-- -   Must contain from 2 to 255 alphanumeric characters, or hyphens.
--
-- -   The first and last character must be a letter or number.
newCreateRelationalDatabaseFromSnapshot ::
  -- | 'relationalDatabaseName'
  Prelude.Text ->
  CreateRelationalDatabaseFromSnapshot
newCreateRelationalDatabaseFromSnapshot :: Text -> CreateRelationalDatabaseFromSnapshot
newCreateRelationalDatabaseFromSnapshot
  Text
pRelationalDatabaseName_ =
    CreateRelationalDatabaseFromSnapshot'
      { $sel:availabilityZone:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
availabilityZone =
          forall a. Maybe a
Prelude.Nothing,
        $sel:publiclyAccessible:CreateRelationalDatabaseFromSnapshot' :: Maybe Bool
publiclyAccessible = forall a. Maybe a
Prelude.Nothing,
        $sel:relationalDatabaseBundleId:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
relationalDatabaseBundleId =
          forall a. Maybe a
Prelude.Nothing,
        $sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
relationalDatabaseSnapshotName =
          forall a. Maybe a
Prelude.Nothing,
        $sel:restoreTime:CreateRelationalDatabaseFromSnapshot' :: Maybe POSIX
restoreTime = forall a. Maybe a
Prelude.Nothing,
        $sel:sourceRelationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
sourceRelationalDatabaseName =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateRelationalDatabaseFromSnapshot' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:useLatestRestorableTime:CreateRelationalDatabaseFromSnapshot' :: Maybe Bool
useLatestRestorableTime =
          forall a. Maybe a
Prelude.Nothing,
        $sel:relationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: Text
relationalDatabaseName =
          Text
pRelationalDatabaseName_
      }

-- | The Availability Zone in which to create your new database. Use the
-- @us-east-2a@ case-sensitive format.
--
-- You can get a list of Availability Zones by using the @get regions@
-- operation. Be sure to add the
-- @include relational database Availability Zones@ parameter to your
-- request.
createRelationalDatabaseFromSnapshot_availabilityZone :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.Text)
createRelationalDatabaseFromSnapshot_availabilityZone :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe Text)
createRelationalDatabaseFromSnapshot_availabilityZone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe Text
availabilityZone :: Maybe Text
$sel:availabilityZone:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
availabilityZone} -> Maybe Text
availabilityZone) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe Text
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:availabilityZone:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
availabilityZone = Maybe Text
a} :: CreateRelationalDatabaseFromSnapshot)

-- | Specifies the accessibility options for your new database. A value of
-- @true@ specifies a database that is available to resources outside of
-- your Lightsail account. A value of @false@ specifies a database that is
-- available only to your Lightsail resources in the same region as your
-- database.
createRelationalDatabaseFromSnapshot_publiclyAccessible :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.Bool)
createRelationalDatabaseFromSnapshot_publiclyAccessible :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe Bool)
createRelationalDatabaseFromSnapshot_publiclyAccessible = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe Bool
publiclyAccessible :: Maybe Bool
$sel:publiclyAccessible:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
publiclyAccessible} -> Maybe Bool
publiclyAccessible) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe Bool
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:publiclyAccessible:CreateRelationalDatabaseFromSnapshot' :: Maybe Bool
publiclyAccessible = Maybe Bool
a} :: CreateRelationalDatabaseFromSnapshot)

-- | The bundle ID for your new database. A bundle describes the performance
-- specifications for your database.
--
-- You can get a list of database bundle IDs by using the
-- @get relational database bundles@ operation.
--
-- When creating a new database from a snapshot, you cannot choose a bundle
-- that is smaller than the bundle of the source database.
createRelationalDatabaseFromSnapshot_relationalDatabaseBundleId :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.Text)
createRelationalDatabaseFromSnapshot_relationalDatabaseBundleId :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe Text)
createRelationalDatabaseFromSnapshot_relationalDatabaseBundleId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe Text
relationalDatabaseBundleId :: Maybe Text
$sel:relationalDatabaseBundleId:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
relationalDatabaseBundleId} -> Maybe Text
relationalDatabaseBundleId) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe Text
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:relationalDatabaseBundleId:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
relationalDatabaseBundleId = Maybe Text
a} :: CreateRelationalDatabaseFromSnapshot)

-- | The name of the database snapshot from which to create your new
-- database.
createRelationalDatabaseFromSnapshot_relationalDatabaseSnapshotName :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.Text)
createRelationalDatabaseFromSnapshot_relationalDatabaseSnapshotName :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe Text)
createRelationalDatabaseFromSnapshot_relationalDatabaseSnapshotName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe Text
relationalDatabaseSnapshotName :: Maybe Text
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
relationalDatabaseSnapshotName} -> Maybe Text
relationalDatabaseSnapshotName) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe Text
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
relationalDatabaseSnapshotName = Maybe Text
a} :: CreateRelationalDatabaseFromSnapshot)

-- | The date and time to restore your database from.
--
-- Constraints:
--
-- -   Must be before the latest restorable time for the database.
--
-- -   Cannot be specified if the @use latest restorable time@ parameter is
--     @true@.
--
-- -   Specified in Coordinated Universal Time (UTC).
--
-- -   Specified in the Unix time format.
--
--     For example, if you wish to use a restore time of October 1, 2018,
--     at 8 PM UTC, then you input @1538424000@ as the restore time.
createRelationalDatabaseFromSnapshot_restoreTime :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.UTCTime)
createRelationalDatabaseFromSnapshot_restoreTime :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe UTCTime)
createRelationalDatabaseFromSnapshot_restoreTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe POSIX
restoreTime :: Maybe POSIX
$sel:restoreTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe POSIX
restoreTime} -> Maybe POSIX
restoreTime) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe POSIX
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:restoreTime:CreateRelationalDatabaseFromSnapshot' :: Maybe POSIX
restoreTime = Maybe POSIX
a} :: CreateRelationalDatabaseFromSnapshot) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The name of the source database.
createRelationalDatabaseFromSnapshot_sourceRelationalDatabaseName :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.Text)
createRelationalDatabaseFromSnapshot_sourceRelationalDatabaseName :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe Text)
createRelationalDatabaseFromSnapshot_sourceRelationalDatabaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe Text
sourceRelationalDatabaseName :: Maybe Text
$sel:sourceRelationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
sourceRelationalDatabaseName} -> Maybe Text
sourceRelationalDatabaseName) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe Text
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:sourceRelationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: Maybe Text
sourceRelationalDatabaseName = Maybe Text
a} :: CreateRelationalDatabaseFromSnapshot)

-- | 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.
createRelationalDatabaseFromSnapshot_tags :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe [Tag])
createRelationalDatabaseFromSnapshot_tags :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe [Tag])
createRelationalDatabaseFromSnapshot_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe [Tag]
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:tags:CreateRelationalDatabaseFromSnapshot' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateRelationalDatabaseFromSnapshot) 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

-- | Specifies whether your database is restored from the latest backup time.
-- A value of @true@ restores from the latest backup time.
--
-- Default: @false@
--
-- Constraints: Cannot be specified if the @restore time@ parameter is
-- provided.
createRelationalDatabaseFromSnapshot_useLatestRestorableTime :: Lens.Lens' CreateRelationalDatabaseFromSnapshot (Prelude.Maybe Prelude.Bool)
createRelationalDatabaseFromSnapshot_useLatestRestorableTime :: Lens' CreateRelationalDatabaseFromSnapshot (Maybe Bool)
createRelationalDatabaseFromSnapshot_useLatestRestorableTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshot' {Maybe Bool
useLatestRestorableTime :: Maybe Bool
$sel:useLatestRestorableTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
useLatestRestorableTime} -> Maybe Bool
useLatestRestorableTime) (\s :: CreateRelationalDatabaseFromSnapshot
s@CreateRelationalDatabaseFromSnapshot' {} Maybe Bool
a -> CreateRelationalDatabaseFromSnapshot
s {$sel:useLatestRestorableTime:CreateRelationalDatabaseFromSnapshot' :: Maybe Bool
useLatestRestorableTime = Maybe Bool
a} :: CreateRelationalDatabaseFromSnapshot)

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

instance
  Core.AWSRequest
    CreateRelationalDatabaseFromSnapshot
  where
  type
    AWSResponse CreateRelationalDatabaseFromSnapshot =
      CreateRelationalDatabaseFromSnapshotResponse
  request :: (Service -> Service)
-> CreateRelationalDatabaseFromSnapshot
-> Request CreateRelationalDatabaseFromSnapshot
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 CreateRelationalDatabaseFromSnapshot
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse
           (AWSResponse CreateRelationalDatabaseFromSnapshot)))
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 -> CreateRelationalDatabaseFromSnapshotResponse
CreateRelationalDatabaseFromSnapshotResponse'
            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
    CreateRelationalDatabaseFromSnapshot
  where
  hashWithSalt :: Int -> CreateRelationalDatabaseFromSnapshot -> Int
hashWithSalt
    Int
_salt
    CreateRelationalDatabaseFromSnapshot' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe POSIX
Text
relationalDatabaseName :: Text
useLatestRestorableTime :: Maybe Bool
tags :: Maybe [Tag]
sourceRelationalDatabaseName :: Maybe Text
restoreTime :: Maybe POSIX
relationalDatabaseSnapshotName :: Maybe Text
relationalDatabaseBundleId :: Maybe Text
publiclyAccessible :: Maybe Bool
availabilityZone :: Maybe Text
$sel:relationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Text
$sel:useLatestRestorableTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
$sel:tags:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe [Tag]
$sel:sourceRelationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:restoreTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe POSIX
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:relationalDatabaseBundleId:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:publiclyAccessible:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
$sel:availabilityZone:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
availabilityZone
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
publiclyAccessible
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
relationalDatabaseBundleId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
relationalDatabaseSnapshotName
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
restoreTime
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
sourceRelationalDatabaseName
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
useLatestRestorableTime
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
relationalDatabaseName

instance
  Prelude.NFData
    CreateRelationalDatabaseFromSnapshot
  where
  rnf :: CreateRelationalDatabaseFromSnapshot -> ()
rnf CreateRelationalDatabaseFromSnapshot' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe POSIX
Text
relationalDatabaseName :: Text
useLatestRestorableTime :: Maybe Bool
tags :: Maybe [Tag]
sourceRelationalDatabaseName :: Maybe Text
restoreTime :: Maybe POSIX
relationalDatabaseSnapshotName :: Maybe Text
relationalDatabaseBundleId :: Maybe Text
publiclyAccessible :: Maybe Bool
availabilityZone :: Maybe Text
$sel:relationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Text
$sel:useLatestRestorableTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
$sel:tags:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe [Tag]
$sel:sourceRelationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:restoreTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe POSIX
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:relationalDatabaseBundleId:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:publiclyAccessible:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
$sel:availabilityZone:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
availabilityZone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
publiclyAccessible
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
relationalDatabaseBundleId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
relationalDatabaseSnapshotName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
restoreTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
sourceRelationalDatabaseName
      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 Maybe Bool
useLatestRestorableTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
relationalDatabaseName

instance
  Data.ToHeaders
    CreateRelationalDatabaseFromSnapshot
  where
  toHeaders :: CreateRelationalDatabaseFromSnapshot -> 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.CreateRelationalDatabaseFromSnapshot" ::
                          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
    CreateRelationalDatabaseFromSnapshot
  where
  toJSON :: CreateRelationalDatabaseFromSnapshot -> Value
toJSON CreateRelationalDatabaseFromSnapshot' {Maybe Bool
Maybe [Tag]
Maybe Text
Maybe POSIX
Text
relationalDatabaseName :: Text
useLatestRestorableTime :: Maybe Bool
tags :: Maybe [Tag]
sourceRelationalDatabaseName :: Maybe Text
restoreTime :: Maybe POSIX
relationalDatabaseSnapshotName :: Maybe Text
relationalDatabaseBundleId :: Maybe Text
publiclyAccessible :: Maybe Bool
availabilityZone :: Maybe Text
$sel:relationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Text
$sel:useLatestRestorableTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
$sel:tags:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe [Tag]
$sel:sourceRelationalDatabaseName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:restoreTime:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe POSIX
$sel:relationalDatabaseSnapshotName:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:relationalDatabaseBundleId:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
$sel:publiclyAccessible:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Bool
$sel:availabilityZone:CreateRelationalDatabaseFromSnapshot' :: CreateRelationalDatabaseFromSnapshot -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"availabilityZone" 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
availabilityZone,
            (Key
"publiclyAccessible" 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 Bool
publiclyAccessible,
            (Key
"relationalDatabaseBundleId" 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
relationalDatabaseBundleId,
            (Key
"relationalDatabaseSnapshotName" 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
relationalDatabaseSnapshotName,
            (Key
"restoreTime" 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 POSIX
restoreTime,
            (Key
"sourceRelationalDatabaseName" 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
sourceRelationalDatabaseName,
            (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,
            (Key
"useLatestRestorableTime" 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 Bool
useLatestRestorableTime,
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"relationalDatabaseName"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
relationalDatabaseName
              )
          ]
      )

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

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

-- | /See:/ 'newCreateRelationalDatabaseFromSnapshotResponse' smart constructor.
data CreateRelationalDatabaseFromSnapshotResponse = CreateRelationalDatabaseFromSnapshotResponse'
  { -- | 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.
    CreateRelationalDatabaseFromSnapshotResponse -> Maybe [Operation]
operations :: Prelude.Maybe [Operation],
    -- | The response's http status code.
    CreateRelationalDatabaseFromSnapshotResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateRelationalDatabaseFromSnapshotResponse
-> CreateRelationalDatabaseFromSnapshotResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRelationalDatabaseFromSnapshotResponse
-> CreateRelationalDatabaseFromSnapshotResponse -> Bool
$c/= :: CreateRelationalDatabaseFromSnapshotResponse
-> CreateRelationalDatabaseFromSnapshotResponse -> Bool
== :: CreateRelationalDatabaseFromSnapshotResponse
-> CreateRelationalDatabaseFromSnapshotResponse -> Bool
$c== :: CreateRelationalDatabaseFromSnapshotResponse
-> CreateRelationalDatabaseFromSnapshotResponse -> Bool
Prelude.Eq, ReadPrec [CreateRelationalDatabaseFromSnapshotResponse]
ReadPrec CreateRelationalDatabaseFromSnapshotResponse
Int -> ReadS CreateRelationalDatabaseFromSnapshotResponse
ReadS [CreateRelationalDatabaseFromSnapshotResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRelationalDatabaseFromSnapshotResponse]
$creadListPrec :: ReadPrec [CreateRelationalDatabaseFromSnapshotResponse]
readPrec :: ReadPrec CreateRelationalDatabaseFromSnapshotResponse
$creadPrec :: ReadPrec CreateRelationalDatabaseFromSnapshotResponse
readList :: ReadS [CreateRelationalDatabaseFromSnapshotResponse]
$creadList :: ReadS [CreateRelationalDatabaseFromSnapshotResponse]
readsPrec :: Int -> ReadS CreateRelationalDatabaseFromSnapshotResponse
$creadsPrec :: Int -> ReadS CreateRelationalDatabaseFromSnapshotResponse
Prelude.Read, Int -> CreateRelationalDatabaseFromSnapshotResponse -> ShowS
[CreateRelationalDatabaseFromSnapshotResponse] -> ShowS
CreateRelationalDatabaseFromSnapshotResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRelationalDatabaseFromSnapshotResponse] -> ShowS
$cshowList :: [CreateRelationalDatabaseFromSnapshotResponse] -> ShowS
show :: CreateRelationalDatabaseFromSnapshotResponse -> String
$cshow :: CreateRelationalDatabaseFromSnapshotResponse -> String
showsPrec :: Int -> CreateRelationalDatabaseFromSnapshotResponse -> ShowS
$cshowsPrec :: Int -> CreateRelationalDatabaseFromSnapshotResponse -> ShowS
Prelude.Show, forall x.
Rep CreateRelationalDatabaseFromSnapshotResponse x
-> CreateRelationalDatabaseFromSnapshotResponse
forall x.
CreateRelationalDatabaseFromSnapshotResponse
-> Rep CreateRelationalDatabaseFromSnapshotResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateRelationalDatabaseFromSnapshotResponse x
-> CreateRelationalDatabaseFromSnapshotResponse
$cfrom :: forall x.
CreateRelationalDatabaseFromSnapshotResponse
-> Rep CreateRelationalDatabaseFromSnapshotResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateRelationalDatabaseFromSnapshotResponse' 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', 'createRelationalDatabaseFromSnapshotResponse_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', 'createRelationalDatabaseFromSnapshotResponse_httpStatus' - The response's http status code.
newCreateRelationalDatabaseFromSnapshotResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateRelationalDatabaseFromSnapshotResponse
newCreateRelationalDatabaseFromSnapshotResponse :: Int -> CreateRelationalDatabaseFromSnapshotResponse
newCreateRelationalDatabaseFromSnapshotResponse
  Int
pHttpStatus_ =
    CreateRelationalDatabaseFromSnapshotResponse'
      { $sel:operations:CreateRelationalDatabaseFromSnapshotResponse' :: Maybe [Operation]
operations =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateRelationalDatabaseFromSnapshotResponse' :: 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.
createRelationalDatabaseFromSnapshotResponse_operations :: Lens.Lens' CreateRelationalDatabaseFromSnapshotResponse (Prelude.Maybe [Operation])
createRelationalDatabaseFromSnapshotResponse_operations :: Lens'
  CreateRelationalDatabaseFromSnapshotResponse (Maybe [Operation])
createRelationalDatabaseFromSnapshotResponse_operations = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshotResponse' {Maybe [Operation]
operations :: Maybe [Operation]
$sel:operations:CreateRelationalDatabaseFromSnapshotResponse' :: CreateRelationalDatabaseFromSnapshotResponse -> Maybe [Operation]
operations} -> Maybe [Operation]
operations) (\s :: CreateRelationalDatabaseFromSnapshotResponse
s@CreateRelationalDatabaseFromSnapshotResponse' {} Maybe [Operation]
a -> CreateRelationalDatabaseFromSnapshotResponse
s {$sel:operations:CreateRelationalDatabaseFromSnapshotResponse' :: Maybe [Operation]
operations = Maybe [Operation]
a} :: CreateRelationalDatabaseFromSnapshotResponse) 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.
createRelationalDatabaseFromSnapshotResponse_httpStatus :: Lens.Lens' CreateRelationalDatabaseFromSnapshotResponse Prelude.Int
createRelationalDatabaseFromSnapshotResponse_httpStatus :: Lens' CreateRelationalDatabaseFromSnapshotResponse Int
createRelationalDatabaseFromSnapshotResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRelationalDatabaseFromSnapshotResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateRelationalDatabaseFromSnapshotResponse' :: CreateRelationalDatabaseFromSnapshotResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateRelationalDatabaseFromSnapshotResponse
s@CreateRelationalDatabaseFromSnapshotResponse' {} Int
a -> CreateRelationalDatabaseFromSnapshotResponse
s {$sel:httpStatus:CreateRelationalDatabaseFromSnapshotResponse' :: Int
httpStatus = Int
a} :: CreateRelationalDatabaseFromSnapshotResponse)

instance
  Prelude.NFData
    CreateRelationalDatabaseFromSnapshotResponse
  where
  rnf :: CreateRelationalDatabaseFromSnapshotResponse -> ()
rnf CreateRelationalDatabaseFromSnapshotResponse' {Int
Maybe [Operation]
httpStatus :: Int
operations :: Maybe [Operation]
$sel:httpStatus:CreateRelationalDatabaseFromSnapshotResponse' :: CreateRelationalDatabaseFromSnapshotResponse -> Int
$sel:operations:CreateRelationalDatabaseFromSnapshotResponse' :: CreateRelationalDatabaseFromSnapshotResponse -> 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