{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.RDS.Types.DBSnapshot
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.RDS.Types.DBSnapshot where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import Amazonka.RDS.Types.ProcessorFeature
import Amazonka.RDS.Types.Tag

-- | Contains the details of an Amazon RDS DB snapshot.
--
-- This data type is used as a response element in the
-- @DescribeDBSnapshots@ action.
--
-- /See:/ 'newDBSnapshot' smart constructor.
data DBSnapshot = DBSnapshot'
  { -- | Specifies the time of the CreateDBSnapshot operation in Coordinated
    -- Universal Time (UTC). Doesn\'t change when the snapshot is copied.
    DBSnapshot -> Maybe ISO8601
originalSnapshotCreateTime :: Prelude.Maybe Core.ISO8601,
    -- | Specifies the version of the database engine.
    DBSnapshot -> Maybe Text
engineVersion :: Prelude.Maybe Prelude.Text,
    -- | Specifies the status of this DB snapshot.
    DBSnapshot -> Maybe Text
status :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) for the DB snapshot.
    DBSnapshot -> Maybe Text
dbSnapshotArn :: Prelude.Maybe Prelude.Text,
    -- | Provides the master username for the DB snapshot.
    DBSnapshot -> Maybe Text
masterUsername :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Web Services Region that the DB snapshot was created in or
    -- copied from.
    DBSnapshot -> Maybe Text
sourceRegion :: Prelude.Maybe Prelude.Text,
    -- | True if mapping of Amazon Web Services Identity and Access Management
    -- (IAM) accounts to database accounts is enabled, and otherwise false.
    DBSnapshot -> Maybe Bool
iAMDatabaseAuthenticationEnabled :: Prelude.Maybe Prelude.Bool,
    -- | Specifies the Provisioned IOPS (I\/O operations per second) value of the
    -- DB instance at the time of the snapshot.
    DBSnapshot -> Maybe Int
iops :: Prelude.Maybe Prelude.Int,
    -- | Provides the VPC ID associated with the DB snapshot.
    DBSnapshot -> Maybe Text
vpcId :: Prelude.Maybe Prelude.Text,
    -- | Specifies the time in Coordinated Universal Time (UTC) when the DB
    -- instance, from which the snapshot was taken, was created.
    DBSnapshot -> Maybe ISO8601
instanceCreateTime :: Prelude.Maybe Core.ISO8601,
    DBSnapshot -> Maybe [Tag]
tagList :: Prelude.Maybe [Tag],
    -- | Specifies the name of the database engine.
    DBSnapshot -> Maybe Text
engine :: Prelude.Maybe Prelude.Text,
    -- | Specifies whether the DB snapshot is encrypted.
    DBSnapshot -> Maybe Bool
encrypted :: Prelude.Maybe Prelude.Bool,
    -- | Specifies the identifier for the DB snapshot.
    DBSnapshot -> Maybe Text
dbSnapshotIdentifier :: Prelude.Maybe Prelude.Text,
    -- | The number of CPU cores and the number of threads per core for the DB
    -- instance class of the DB instance when the DB snapshot was created.
    DBSnapshot -> Maybe [ProcessorFeature]
processorFeatures :: Prelude.Maybe [ProcessorFeature],
    -- | License model information for the restored DB instance.
    DBSnapshot -> Maybe Text
licenseModel :: Prelude.Maybe Prelude.Text,
    -- | The DB snapshot Amazon Resource Name (ARN) that the DB snapshot was
    -- copied from. It only has a value in the case of a cross-account or
    -- cross-Region copy.
    DBSnapshot -> Maybe Text
sourceDBSnapshotIdentifier :: Prelude.Maybe Prelude.Text,
    -- | Provides the type of the DB snapshot.
    DBSnapshot -> Maybe Text
snapshotType :: Prelude.Maybe Prelude.Text,
    -- | Specifies the DB instance identifier of the DB instance this DB snapshot
    -- was created from.
    DBSnapshot -> Maybe Text
dbInstanceIdentifier :: Prelude.Maybe Prelude.Text,
    -- | If @Encrypted@ is true, the Amazon Web Services KMS key identifier for
    -- the encrypted DB snapshot.
    --
    -- The Amazon Web Services KMS key identifier is the key ARN, key ID, alias
    -- ARN, or alias name for the Amazon Web Services KMS customer master key
    -- (CMK).
    DBSnapshot -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | Specifies the name of the Availability Zone the DB instance was located
    -- in at the time of the DB snapshot.
    DBSnapshot -> Maybe Text
availabilityZone :: Prelude.Maybe Prelude.Text,
    -- | Specifies when the snapshot was taken in Coordinated Universal Time
    -- (UTC). Changes for the copy when the snapshot is copied.
    DBSnapshot -> Maybe ISO8601
snapshotCreateTime :: Prelude.Maybe Core.ISO8601,
    -- | Specifies the allocated storage size in gibibytes (GiB).
    DBSnapshot -> Maybe Int
allocatedStorage :: Prelude.Maybe Prelude.Int,
    -- | The identifier for the source DB instance, which can\'t be changed and
    -- which is unique to an Amazon Web Services Region.
    DBSnapshot -> Maybe Text
dbiResourceId :: Prelude.Maybe Prelude.Text,
    -- | Provides the option group name for the DB snapshot.
    DBSnapshot -> Maybe Text
optionGroupName :: Prelude.Maybe Prelude.Text,
    -- | The time zone of the DB snapshot. In most cases, the @Timezone@ element
    -- is empty. @Timezone@ content appears only for snapshots taken from
    -- Microsoft SQL Server DB instances that were created with a time zone
    -- specified.
    DBSnapshot -> Maybe Text
timezone :: Prelude.Maybe Prelude.Text,
    -- | The ARN from the key store with which to associate the instance for TDE
    -- encryption.
    DBSnapshot -> Maybe Text
tdeCredentialArn :: Prelude.Maybe Prelude.Text,
    -- | The percentage of the estimated data that has been transferred.
    DBSnapshot -> Maybe Int
percentProgress :: Prelude.Maybe Prelude.Int,
    -- | Specifies the port that the database engine was listening on at the time
    -- of the snapshot.
    DBSnapshot -> Maybe Int
port :: Prelude.Maybe Prelude.Int,
    -- | Specifies the storage type associated with DB snapshot.
    DBSnapshot -> Maybe Text
storageType :: Prelude.Maybe Prelude.Text
  }
  deriving (DBSnapshot -> DBSnapshot -> Bool
(DBSnapshot -> DBSnapshot -> Bool)
-> (DBSnapshot -> DBSnapshot -> Bool) -> Eq DBSnapshot
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBSnapshot -> DBSnapshot -> Bool
$c/= :: DBSnapshot -> DBSnapshot -> Bool
== :: DBSnapshot -> DBSnapshot -> Bool
$c== :: DBSnapshot -> DBSnapshot -> Bool
Prelude.Eq, ReadPrec [DBSnapshot]
ReadPrec DBSnapshot
Int -> ReadS DBSnapshot
ReadS [DBSnapshot]
(Int -> ReadS DBSnapshot)
-> ReadS [DBSnapshot]
-> ReadPrec DBSnapshot
-> ReadPrec [DBSnapshot]
-> Read DBSnapshot
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DBSnapshot]
$creadListPrec :: ReadPrec [DBSnapshot]
readPrec :: ReadPrec DBSnapshot
$creadPrec :: ReadPrec DBSnapshot
readList :: ReadS [DBSnapshot]
$creadList :: ReadS [DBSnapshot]
readsPrec :: Int -> ReadS DBSnapshot
$creadsPrec :: Int -> ReadS DBSnapshot
Prelude.Read, Int -> DBSnapshot -> ShowS
[DBSnapshot] -> ShowS
DBSnapshot -> String
(Int -> DBSnapshot -> ShowS)
-> (DBSnapshot -> String)
-> ([DBSnapshot] -> ShowS)
-> Show DBSnapshot
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBSnapshot] -> ShowS
$cshowList :: [DBSnapshot] -> ShowS
show :: DBSnapshot -> String
$cshow :: DBSnapshot -> String
showsPrec :: Int -> DBSnapshot -> ShowS
$cshowsPrec :: Int -> DBSnapshot -> ShowS
Prelude.Show, (forall x. DBSnapshot -> Rep DBSnapshot x)
-> (forall x. Rep DBSnapshot x -> DBSnapshot) -> Generic DBSnapshot
forall x. Rep DBSnapshot x -> DBSnapshot
forall x. DBSnapshot -> Rep DBSnapshot x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DBSnapshot x -> DBSnapshot
$cfrom :: forall x. DBSnapshot -> Rep DBSnapshot x
Prelude.Generic)

-- |
-- Create a value of 'DBSnapshot' 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:
--
-- 'originalSnapshotCreateTime', 'dbSnapshot_originalSnapshotCreateTime' - Specifies the time of the CreateDBSnapshot operation in Coordinated
-- Universal Time (UTC). Doesn\'t change when the snapshot is copied.
--
-- 'engineVersion', 'dbSnapshot_engineVersion' - Specifies the version of the database engine.
--
-- 'status', 'dbSnapshot_status' - Specifies the status of this DB snapshot.
--
-- 'dbSnapshotArn', 'dbSnapshot_dbSnapshotArn' - The Amazon Resource Name (ARN) for the DB snapshot.
--
-- 'masterUsername', 'dbSnapshot_masterUsername' - Provides the master username for the DB snapshot.
--
-- 'sourceRegion', 'dbSnapshot_sourceRegion' - The Amazon Web Services Region that the DB snapshot was created in or
-- copied from.
--
-- 'iAMDatabaseAuthenticationEnabled', 'dbSnapshot_iAMDatabaseAuthenticationEnabled' - True if mapping of Amazon Web Services Identity and Access Management
-- (IAM) accounts to database accounts is enabled, and otherwise false.
--
-- 'iops', 'dbSnapshot_iops' - Specifies the Provisioned IOPS (I\/O operations per second) value of the
-- DB instance at the time of the snapshot.
--
-- 'vpcId', 'dbSnapshot_vpcId' - Provides the VPC ID associated with the DB snapshot.
--
-- 'instanceCreateTime', 'dbSnapshot_instanceCreateTime' - Specifies the time in Coordinated Universal Time (UTC) when the DB
-- instance, from which the snapshot was taken, was created.
--
-- 'tagList', 'dbSnapshot_tagList' - Undocumented member.
--
-- 'engine', 'dbSnapshot_engine' - Specifies the name of the database engine.
--
-- 'encrypted', 'dbSnapshot_encrypted' - Specifies whether the DB snapshot is encrypted.
--
-- 'dbSnapshotIdentifier', 'dbSnapshot_dbSnapshotIdentifier' - Specifies the identifier for the DB snapshot.
--
-- 'processorFeatures', 'dbSnapshot_processorFeatures' - The number of CPU cores and the number of threads per core for the DB
-- instance class of the DB instance when the DB snapshot was created.
--
-- 'licenseModel', 'dbSnapshot_licenseModel' - License model information for the restored DB instance.
--
-- 'sourceDBSnapshotIdentifier', 'dbSnapshot_sourceDBSnapshotIdentifier' - The DB snapshot Amazon Resource Name (ARN) that the DB snapshot was
-- copied from. It only has a value in the case of a cross-account or
-- cross-Region copy.
--
-- 'snapshotType', 'dbSnapshot_snapshotType' - Provides the type of the DB snapshot.
--
-- 'dbInstanceIdentifier', 'dbSnapshot_dbInstanceIdentifier' - Specifies the DB instance identifier of the DB instance this DB snapshot
-- was created from.
--
-- 'kmsKeyId', 'dbSnapshot_kmsKeyId' - If @Encrypted@ is true, the Amazon Web Services KMS key identifier for
-- the encrypted DB snapshot.
--
-- The Amazon Web Services KMS key identifier is the key ARN, key ID, alias
-- ARN, or alias name for the Amazon Web Services KMS customer master key
-- (CMK).
--
-- 'availabilityZone', 'dbSnapshot_availabilityZone' - Specifies the name of the Availability Zone the DB instance was located
-- in at the time of the DB snapshot.
--
-- 'snapshotCreateTime', 'dbSnapshot_snapshotCreateTime' - Specifies when the snapshot was taken in Coordinated Universal Time
-- (UTC). Changes for the copy when the snapshot is copied.
--
-- 'allocatedStorage', 'dbSnapshot_allocatedStorage' - Specifies the allocated storage size in gibibytes (GiB).
--
-- 'dbiResourceId', 'dbSnapshot_dbiResourceId' - The identifier for the source DB instance, which can\'t be changed and
-- which is unique to an Amazon Web Services Region.
--
-- 'optionGroupName', 'dbSnapshot_optionGroupName' - Provides the option group name for the DB snapshot.
--
-- 'timezone', 'dbSnapshot_timezone' - The time zone of the DB snapshot. In most cases, the @Timezone@ element
-- is empty. @Timezone@ content appears only for snapshots taken from
-- Microsoft SQL Server DB instances that were created with a time zone
-- specified.
--
-- 'tdeCredentialArn', 'dbSnapshot_tdeCredentialArn' - The ARN from the key store with which to associate the instance for TDE
-- encryption.
--
-- 'percentProgress', 'dbSnapshot_percentProgress' - The percentage of the estimated data that has been transferred.
--
-- 'port', 'dbSnapshot_port' - Specifies the port that the database engine was listening on at the time
-- of the snapshot.
--
-- 'storageType', 'dbSnapshot_storageType' - Specifies the storage type associated with DB snapshot.
newDBSnapshot ::
  DBSnapshot
newDBSnapshot :: DBSnapshot
newDBSnapshot =
  DBSnapshot' :: Maybe ISO8601
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Int
-> Maybe Text
-> Maybe ISO8601
-> Maybe [Tag]
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe [ProcessorFeature]
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe ISO8601
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> DBSnapshot
DBSnapshot'
    { $sel:originalSnapshotCreateTime:DBSnapshot' :: Maybe ISO8601
originalSnapshotCreateTime =
        Maybe ISO8601
forall a. Maybe a
Prelude.Nothing,
      $sel:engineVersion:DBSnapshot' :: Maybe Text
engineVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:status:DBSnapshot' :: Maybe Text
status = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:dbSnapshotArn:DBSnapshot' :: Maybe Text
dbSnapshotArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:masterUsername:DBSnapshot' :: Maybe Text
masterUsername = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceRegion:DBSnapshot' :: Maybe Text
sourceRegion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:iAMDatabaseAuthenticationEnabled:DBSnapshot' :: Maybe Bool
iAMDatabaseAuthenticationEnabled = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:iops:DBSnapshot' :: Maybe Int
iops = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:vpcId:DBSnapshot' :: Maybe Text
vpcId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:instanceCreateTime:DBSnapshot' :: Maybe ISO8601
instanceCreateTime = Maybe ISO8601
forall a. Maybe a
Prelude.Nothing,
      $sel:tagList:DBSnapshot' :: Maybe [Tag]
tagList = Maybe [Tag]
forall a. Maybe a
Prelude.Nothing,
      $sel:engine:DBSnapshot' :: Maybe Text
engine = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:encrypted:DBSnapshot' :: Maybe Bool
encrypted = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:dbSnapshotIdentifier:DBSnapshot' :: Maybe Text
dbSnapshotIdentifier = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:processorFeatures:DBSnapshot' :: Maybe [ProcessorFeature]
processorFeatures = Maybe [ProcessorFeature]
forall a. Maybe a
Prelude.Nothing,
      $sel:licenseModel:DBSnapshot' :: Maybe Text
licenseModel = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:sourceDBSnapshotIdentifier:DBSnapshot' :: Maybe Text
sourceDBSnapshotIdentifier = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotType:DBSnapshot' :: Maybe Text
snapshotType = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:dbInstanceIdentifier:DBSnapshot' :: Maybe Text
dbInstanceIdentifier = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:kmsKeyId:DBSnapshot' :: Maybe Text
kmsKeyId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZone:DBSnapshot' :: Maybe Text
availabilityZone = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotCreateTime:DBSnapshot' :: Maybe ISO8601
snapshotCreateTime = Maybe ISO8601
forall a. Maybe a
Prelude.Nothing,
      $sel:allocatedStorage:DBSnapshot' :: Maybe Int
allocatedStorage = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:dbiResourceId:DBSnapshot' :: Maybe Text
dbiResourceId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:optionGroupName:DBSnapshot' :: Maybe Text
optionGroupName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:timezone:DBSnapshot' :: Maybe Text
timezone = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tdeCredentialArn:DBSnapshot' :: Maybe Text
tdeCredentialArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:percentProgress:DBSnapshot' :: Maybe Int
percentProgress = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:port:DBSnapshot' :: Maybe Int
port = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:storageType:DBSnapshot' :: Maybe Text
storageType = Maybe Text
forall a. Maybe a
Prelude.Nothing
    }

-- | Specifies the time of the CreateDBSnapshot operation in Coordinated
-- Universal Time (UTC). Doesn\'t change when the snapshot is copied.
dbSnapshot_originalSnapshotCreateTime :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.UTCTime)
dbSnapshot_originalSnapshotCreateTime :: (Maybe UTCTime -> f (Maybe UTCTime)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_originalSnapshotCreateTime = (DBSnapshot -> Maybe ISO8601)
-> (DBSnapshot -> Maybe ISO8601 -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe ISO8601) (Maybe ISO8601)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe ISO8601
originalSnapshotCreateTime :: Maybe ISO8601
$sel:originalSnapshotCreateTime:DBSnapshot' :: DBSnapshot -> Maybe ISO8601
originalSnapshotCreateTime} -> Maybe ISO8601
originalSnapshotCreateTime) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe ISO8601
a -> DBSnapshot
s {$sel:originalSnapshotCreateTime:DBSnapshot' :: Maybe ISO8601
originalSnapshotCreateTime = Maybe ISO8601
a} :: DBSnapshot) ((Maybe ISO8601 -> f (Maybe ISO8601))
 -> DBSnapshot -> f DBSnapshot)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe ISO8601 -> f (Maybe ISO8601))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> DBSnapshot
-> f DBSnapshot
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso ISO8601 ISO8601 UTCTime UTCTime
-> Iso
     (Maybe ISO8601) (Maybe ISO8601) (Maybe UTCTime) (Maybe UTCTime)
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 AnIso ISO8601 ISO8601 UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | Specifies the version of the database engine.
dbSnapshot_engineVersion :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_engineVersion :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_engineVersion = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
engineVersion :: Maybe Text
$sel:engineVersion:DBSnapshot' :: DBSnapshot -> Maybe Text
engineVersion} -> Maybe Text
engineVersion) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:engineVersion:DBSnapshot' :: Maybe Text
engineVersion = Maybe Text
a} :: DBSnapshot)

-- | Specifies the status of this DB snapshot.
dbSnapshot_status :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_status :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_status = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
status :: Maybe Text
$sel:status:DBSnapshot' :: DBSnapshot -> Maybe Text
status} -> Maybe Text
status) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:status:DBSnapshot' :: Maybe Text
status = Maybe Text
a} :: DBSnapshot)

-- | The Amazon Resource Name (ARN) for the DB snapshot.
dbSnapshot_dbSnapshotArn :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_dbSnapshotArn :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_dbSnapshotArn = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
dbSnapshotArn :: Maybe Text
$sel:dbSnapshotArn:DBSnapshot' :: DBSnapshot -> Maybe Text
dbSnapshotArn} -> Maybe Text
dbSnapshotArn) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:dbSnapshotArn:DBSnapshot' :: Maybe Text
dbSnapshotArn = Maybe Text
a} :: DBSnapshot)

-- | Provides the master username for the DB snapshot.
dbSnapshot_masterUsername :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_masterUsername :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_masterUsername = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
masterUsername :: Maybe Text
$sel:masterUsername:DBSnapshot' :: DBSnapshot -> Maybe Text
masterUsername} -> Maybe Text
masterUsername) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:masterUsername:DBSnapshot' :: Maybe Text
masterUsername = Maybe Text
a} :: DBSnapshot)

-- | The Amazon Web Services Region that the DB snapshot was created in or
-- copied from.
dbSnapshot_sourceRegion :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_sourceRegion :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_sourceRegion = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
sourceRegion :: Maybe Text
$sel:sourceRegion:DBSnapshot' :: DBSnapshot -> Maybe Text
sourceRegion} -> Maybe Text
sourceRegion) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:sourceRegion:DBSnapshot' :: Maybe Text
sourceRegion = Maybe Text
a} :: DBSnapshot)

-- | True if mapping of Amazon Web Services Identity and Access Management
-- (IAM) accounts to database accounts is enabled, and otherwise false.
dbSnapshot_iAMDatabaseAuthenticationEnabled :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Bool)
dbSnapshot_iAMDatabaseAuthenticationEnabled :: (Maybe Bool -> f (Maybe Bool)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_iAMDatabaseAuthenticationEnabled = (DBSnapshot -> Maybe Bool)
-> (DBSnapshot -> Maybe Bool -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Bool
iAMDatabaseAuthenticationEnabled :: Maybe Bool
$sel:iAMDatabaseAuthenticationEnabled:DBSnapshot' :: DBSnapshot -> Maybe Bool
iAMDatabaseAuthenticationEnabled} -> Maybe Bool
iAMDatabaseAuthenticationEnabled) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Bool
a -> DBSnapshot
s {$sel:iAMDatabaseAuthenticationEnabled:DBSnapshot' :: Maybe Bool
iAMDatabaseAuthenticationEnabled = Maybe Bool
a} :: DBSnapshot)

-- | Specifies the Provisioned IOPS (I\/O operations per second) value of the
-- DB instance at the time of the snapshot.
dbSnapshot_iops :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Int)
dbSnapshot_iops :: (Maybe Int -> f (Maybe Int)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_iops = (DBSnapshot -> Maybe Int)
-> (DBSnapshot -> Maybe Int -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Int
iops :: Maybe Int
$sel:iops:DBSnapshot' :: DBSnapshot -> Maybe Int
iops} -> Maybe Int
iops) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Int
a -> DBSnapshot
s {$sel:iops:DBSnapshot' :: Maybe Int
iops = Maybe Int
a} :: DBSnapshot)

-- | Provides the VPC ID associated with the DB snapshot.
dbSnapshot_vpcId :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_vpcId :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_vpcId = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
vpcId :: Maybe Text
$sel:vpcId:DBSnapshot' :: DBSnapshot -> Maybe Text
vpcId} -> Maybe Text
vpcId) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:vpcId:DBSnapshot' :: Maybe Text
vpcId = Maybe Text
a} :: DBSnapshot)

-- | Specifies the time in Coordinated Universal Time (UTC) when the DB
-- instance, from which the snapshot was taken, was created.
dbSnapshot_instanceCreateTime :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.UTCTime)
dbSnapshot_instanceCreateTime :: (Maybe UTCTime -> f (Maybe UTCTime)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_instanceCreateTime = (DBSnapshot -> Maybe ISO8601)
-> (DBSnapshot -> Maybe ISO8601 -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe ISO8601) (Maybe ISO8601)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe ISO8601
instanceCreateTime :: Maybe ISO8601
$sel:instanceCreateTime:DBSnapshot' :: DBSnapshot -> Maybe ISO8601
instanceCreateTime} -> Maybe ISO8601
instanceCreateTime) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe ISO8601
a -> DBSnapshot
s {$sel:instanceCreateTime:DBSnapshot' :: Maybe ISO8601
instanceCreateTime = Maybe ISO8601
a} :: DBSnapshot) ((Maybe ISO8601 -> f (Maybe ISO8601))
 -> DBSnapshot -> f DBSnapshot)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe ISO8601 -> f (Maybe ISO8601))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> DBSnapshot
-> f DBSnapshot
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso ISO8601 ISO8601 UTCTime UTCTime
-> Iso
     (Maybe ISO8601) (Maybe ISO8601) (Maybe UTCTime) (Maybe UTCTime)
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 AnIso ISO8601 ISO8601 UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | Undocumented member.
dbSnapshot_tagList :: Lens.Lens' DBSnapshot (Prelude.Maybe [Tag])
dbSnapshot_tagList :: (Maybe [Tag] -> f (Maybe [Tag])) -> DBSnapshot -> f DBSnapshot
dbSnapshot_tagList = (DBSnapshot -> Maybe [Tag])
-> (DBSnapshot -> Maybe [Tag] -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe [Tag]) (Maybe [Tag])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe [Tag]
tagList :: Maybe [Tag]
$sel:tagList:DBSnapshot' :: DBSnapshot -> Maybe [Tag]
tagList} -> Maybe [Tag]
tagList) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe [Tag]
a -> DBSnapshot
s {$sel:tagList:DBSnapshot' :: Maybe [Tag]
tagList = Maybe [Tag]
a} :: DBSnapshot) ((Maybe [Tag] -> f (Maybe [Tag])) -> DBSnapshot -> f DBSnapshot)
-> ((Maybe [Tag] -> f (Maybe [Tag]))
    -> Maybe [Tag] -> f (Maybe [Tag]))
-> (Maybe [Tag] -> f (Maybe [Tag]))
-> DBSnapshot
-> f DBSnapshot
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Tag] [Tag] [Tag] [Tag]
-> Iso (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag]) (Maybe [Tag])
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 AnIso [Tag] [Tag] [Tag] [Tag]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies the name of the database engine.
dbSnapshot_engine :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_engine :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_engine = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
engine :: Maybe Text
$sel:engine:DBSnapshot' :: DBSnapshot -> Maybe Text
engine} -> Maybe Text
engine) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:engine:DBSnapshot' :: Maybe Text
engine = Maybe Text
a} :: DBSnapshot)

-- | Specifies whether the DB snapshot is encrypted.
dbSnapshot_encrypted :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Bool)
dbSnapshot_encrypted :: (Maybe Bool -> f (Maybe Bool)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_encrypted = (DBSnapshot -> Maybe Bool)
-> (DBSnapshot -> Maybe Bool -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Bool
encrypted :: Maybe Bool
$sel:encrypted:DBSnapshot' :: DBSnapshot -> Maybe Bool
encrypted} -> Maybe Bool
encrypted) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Bool
a -> DBSnapshot
s {$sel:encrypted:DBSnapshot' :: Maybe Bool
encrypted = Maybe Bool
a} :: DBSnapshot)

-- | Specifies the identifier for the DB snapshot.
dbSnapshot_dbSnapshotIdentifier :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_dbSnapshotIdentifier :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_dbSnapshotIdentifier = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
dbSnapshotIdentifier :: Maybe Text
$sel:dbSnapshotIdentifier:DBSnapshot' :: DBSnapshot -> Maybe Text
dbSnapshotIdentifier} -> Maybe Text
dbSnapshotIdentifier) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:dbSnapshotIdentifier:DBSnapshot' :: Maybe Text
dbSnapshotIdentifier = Maybe Text
a} :: DBSnapshot)

-- | The number of CPU cores and the number of threads per core for the DB
-- instance class of the DB instance when the DB snapshot was created.
dbSnapshot_processorFeatures :: Lens.Lens' DBSnapshot (Prelude.Maybe [ProcessorFeature])
dbSnapshot_processorFeatures :: (Maybe [ProcessorFeature] -> f (Maybe [ProcessorFeature]))
-> DBSnapshot -> f DBSnapshot
dbSnapshot_processorFeatures = (DBSnapshot -> Maybe [ProcessorFeature])
-> (DBSnapshot -> Maybe [ProcessorFeature] -> DBSnapshot)
-> Lens
     DBSnapshot
     DBSnapshot
     (Maybe [ProcessorFeature])
     (Maybe [ProcessorFeature])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe [ProcessorFeature]
processorFeatures :: Maybe [ProcessorFeature]
$sel:processorFeatures:DBSnapshot' :: DBSnapshot -> Maybe [ProcessorFeature]
processorFeatures} -> Maybe [ProcessorFeature]
processorFeatures) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe [ProcessorFeature]
a -> DBSnapshot
s {$sel:processorFeatures:DBSnapshot' :: Maybe [ProcessorFeature]
processorFeatures = Maybe [ProcessorFeature]
a} :: DBSnapshot) ((Maybe [ProcessorFeature] -> f (Maybe [ProcessorFeature]))
 -> DBSnapshot -> f DBSnapshot)
-> ((Maybe [ProcessorFeature] -> f (Maybe [ProcessorFeature]))
    -> Maybe [ProcessorFeature] -> f (Maybe [ProcessorFeature]))
-> (Maybe [ProcessorFeature] -> f (Maybe [ProcessorFeature]))
-> DBSnapshot
-> f DBSnapshot
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ProcessorFeature]
  [ProcessorFeature]
  [ProcessorFeature]
  [ProcessorFeature]
-> Iso
     (Maybe [ProcessorFeature])
     (Maybe [ProcessorFeature])
     (Maybe [ProcessorFeature])
     (Maybe [ProcessorFeature])
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 AnIso
  [ProcessorFeature]
  [ProcessorFeature]
  [ProcessorFeature]
  [ProcessorFeature]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | License model information for the restored DB instance.
dbSnapshot_licenseModel :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_licenseModel :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_licenseModel = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
licenseModel :: Maybe Text
$sel:licenseModel:DBSnapshot' :: DBSnapshot -> Maybe Text
licenseModel} -> Maybe Text
licenseModel) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:licenseModel:DBSnapshot' :: Maybe Text
licenseModel = Maybe Text
a} :: DBSnapshot)

-- | The DB snapshot Amazon Resource Name (ARN) that the DB snapshot was
-- copied from. It only has a value in the case of a cross-account or
-- cross-Region copy.
dbSnapshot_sourceDBSnapshotIdentifier :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_sourceDBSnapshotIdentifier :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_sourceDBSnapshotIdentifier = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
sourceDBSnapshotIdentifier :: Maybe Text
$sel:sourceDBSnapshotIdentifier:DBSnapshot' :: DBSnapshot -> Maybe Text
sourceDBSnapshotIdentifier} -> Maybe Text
sourceDBSnapshotIdentifier) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:sourceDBSnapshotIdentifier:DBSnapshot' :: Maybe Text
sourceDBSnapshotIdentifier = Maybe Text
a} :: DBSnapshot)

-- | Provides the type of the DB snapshot.
dbSnapshot_snapshotType :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_snapshotType :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_snapshotType = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
snapshotType :: Maybe Text
$sel:snapshotType:DBSnapshot' :: DBSnapshot -> Maybe Text
snapshotType} -> Maybe Text
snapshotType) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:snapshotType:DBSnapshot' :: Maybe Text
snapshotType = Maybe Text
a} :: DBSnapshot)

-- | Specifies the DB instance identifier of the DB instance this DB snapshot
-- was created from.
dbSnapshot_dbInstanceIdentifier :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_dbInstanceIdentifier :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_dbInstanceIdentifier = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
dbInstanceIdentifier :: Maybe Text
$sel:dbInstanceIdentifier:DBSnapshot' :: DBSnapshot -> Maybe Text
dbInstanceIdentifier} -> Maybe Text
dbInstanceIdentifier) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:dbInstanceIdentifier:DBSnapshot' :: Maybe Text
dbInstanceIdentifier = Maybe Text
a} :: DBSnapshot)

-- | If @Encrypted@ is true, the Amazon Web Services KMS key identifier for
-- the encrypted DB snapshot.
--
-- The Amazon Web Services KMS key identifier is the key ARN, key ID, alias
-- ARN, or alias name for the Amazon Web Services KMS customer master key
-- (CMK).
dbSnapshot_kmsKeyId :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_kmsKeyId :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_kmsKeyId = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:DBSnapshot' :: DBSnapshot -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:kmsKeyId:DBSnapshot' :: Maybe Text
kmsKeyId = Maybe Text
a} :: DBSnapshot)

-- | Specifies the name of the Availability Zone the DB instance was located
-- in at the time of the DB snapshot.
dbSnapshot_availabilityZone :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_availabilityZone :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_availabilityZone = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
availabilityZone :: Maybe Text
$sel:availabilityZone:DBSnapshot' :: DBSnapshot -> Maybe Text
availabilityZone} -> Maybe Text
availabilityZone) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:availabilityZone:DBSnapshot' :: Maybe Text
availabilityZone = Maybe Text
a} :: DBSnapshot)

-- | Specifies when the snapshot was taken in Coordinated Universal Time
-- (UTC). Changes for the copy when the snapshot is copied.
dbSnapshot_snapshotCreateTime :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.UTCTime)
dbSnapshot_snapshotCreateTime :: (Maybe UTCTime -> f (Maybe UTCTime)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_snapshotCreateTime = (DBSnapshot -> Maybe ISO8601)
-> (DBSnapshot -> Maybe ISO8601 -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe ISO8601) (Maybe ISO8601)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe ISO8601
snapshotCreateTime :: Maybe ISO8601
$sel:snapshotCreateTime:DBSnapshot' :: DBSnapshot -> Maybe ISO8601
snapshotCreateTime} -> Maybe ISO8601
snapshotCreateTime) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe ISO8601
a -> DBSnapshot
s {$sel:snapshotCreateTime:DBSnapshot' :: Maybe ISO8601
snapshotCreateTime = Maybe ISO8601
a} :: DBSnapshot) ((Maybe ISO8601 -> f (Maybe ISO8601))
 -> DBSnapshot -> f DBSnapshot)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe ISO8601 -> f (Maybe ISO8601))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> DBSnapshot
-> f DBSnapshot
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso ISO8601 ISO8601 UTCTime UTCTime
-> Iso
     (Maybe ISO8601) (Maybe ISO8601) (Maybe UTCTime) (Maybe UTCTime)
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 AnIso ISO8601 ISO8601 UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | Specifies the allocated storage size in gibibytes (GiB).
dbSnapshot_allocatedStorage :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Int)
dbSnapshot_allocatedStorage :: (Maybe Int -> f (Maybe Int)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_allocatedStorage = (DBSnapshot -> Maybe Int)
-> (DBSnapshot -> Maybe Int -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Int
allocatedStorage :: Maybe Int
$sel:allocatedStorage:DBSnapshot' :: DBSnapshot -> Maybe Int
allocatedStorage} -> Maybe Int
allocatedStorage) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Int
a -> DBSnapshot
s {$sel:allocatedStorage:DBSnapshot' :: Maybe Int
allocatedStorage = Maybe Int
a} :: DBSnapshot)

-- | The identifier for the source DB instance, which can\'t be changed and
-- which is unique to an Amazon Web Services Region.
dbSnapshot_dbiResourceId :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_dbiResourceId :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_dbiResourceId = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
dbiResourceId :: Maybe Text
$sel:dbiResourceId:DBSnapshot' :: DBSnapshot -> Maybe Text
dbiResourceId} -> Maybe Text
dbiResourceId) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:dbiResourceId:DBSnapshot' :: Maybe Text
dbiResourceId = Maybe Text
a} :: DBSnapshot)

-- | Provides the option group name for the DB snapshot.
dbSnapshot_optionGroupName :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_optionGroupName :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_optionGroupName = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
optionGroupName :: Maybe Text
$sel:optionGroupName:DBSnapshot' :: DBSnapshot -> Maybe Text
optionGroupName} -> Maybe Text
optionGroupName) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:optionGroupName:DBSnapshot' :: Maybe Text
optionGroupName = Maybe Text
a} :: DBSnapshot)

-- | The time zone of the DB snapshot. In most cases, the @Timezone@ element
-- is empty. @Timezone@ content appears only for snapshots taken from
-- Microsoft SQL Server DB instances that were created with a time zone
-- specified.
dbSnapshot_timezone :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_timezone :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_timezone = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
timezone :: Maybe Text
$sel:timezone:DBSnapshot' :: DBSnapshot -> Maybe Text
timezone} -> Maybe Text
timezone) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:timezone:DBSnapshot' :: Maybe Text
timezone = Maybe Text
a} :: DBSnapshot)

-- | The ARN from the key store with which to associate the instance for TDE
-- encryption.
dbSnapshot_tdeCredentialArn :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_tdeCredentialArn :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_tdeCredentialArn = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
tdeCredentialArn :: Maybe Text
$sel:tdeCredentialArn:DBSnapshot' :: DBSnapshot -> Maybe Text
tdeCredentialArn} -> Maybe Text
tdeCredentialArn) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:tdeCredentialArn:DBSnapshot' :: Maybe Text
tdeCredentialArn = Maybe Text
a} :: DBSnapshot)

-- | The percentage of the estimated data that has been transferred.
dbSnapshot_percentProgress :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Int)
dbSnapshot_percentProgress :: (Maybe Int -> f (Maybe Int)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_percentProgress = (DBSnapshot -> Maybe Int)
-> (DBSnapshot -> Maybe Int -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Int
percentProgress :: Maybe Int
$sel:percentProgress:DBSnapshot' :: DBSnapshot -> Maybe Int
percentProgress} -> Maybe Int
percentProgress) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Int
a -> DBSnapshot
s {$sel:percentProgress:DBSnapshot' :: Maybe Int
percentProgress = Maybe Int
a} :: DBSnapshot)

-- | Specifies the port that the database engine was listening on at the time
-- of the snapshot.
dbSnapshot_port :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Int)
dbSnapshot_port :: (Maybe Int -> f (Maybe Int)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_port = (DBSnapshot -> Maybe Int)
-> (DBSnapshot -> Maybe Int -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Int
port :: Maybe Int
$sel:port:DBSnapshot' :: DBSnapshot -> Maybe Int
port} -> Maybe Int
port) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Int
a -> DBSnapshot
s {$sel:port:DBSnapshot' :: Maybe Int
port = Maybe Int
a} :: DBSnapshot)

-- | Specifies the storage type associated with DB snapshot.
dbSnapshot_storageType :: Lens.Lens' DBSnapshot (Prelude.Maybe Prelude.Text)
dbSnapshot_storageType :: (Maybe Text -> f (Maybe Text)) -> DBSnapshot -> f DBSnapshot
dbSnapshot_storageType = (DBSnapshot -> Maybe Text)
-> (DBSnapshot -> Maybe Text -> DBSnapshot)
-> Lens DBSnapshot DBSnapshot (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBSnapshot' {Maybe Text
storageType :: Maybe Text
$sel:storageType:DBSnapshot' :: DBSnapshot -> Maybe Text
storageType} -> Maybe Text
storageType) (\s :: DBSnapshot
s@DBSnapshot' {} Maybe Text
a -> DBSnapshot
s {$sel:storageType:DBSnapshot' :: Maybe Text
storageType = Maybe Text
a} :: DBSnapshot)

instance Core.FromXML DBSnapshot where
  parseXML :: [Node] -> Either String DBSnapshot
parseXML [Node]
x =
    Maybe ISO8601
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Int
-> Maybe Text
-> Maybe ISO8601
-> Maybe [Tag]
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe [ProcessorFeature]
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe ISO8601
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> DBSnapshot
DBSnapshot'
      (Maybe ISO8601
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Int
 -> Maybe Text
 -> Maybe ISO8601
 -> Maybe [Tag]
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Text
 -> Maybe [ProcessorFeature]
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe ISO8601
 -> Maybe Int
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Int
 -> Maybe Int
 -> Maybe Text
 -> DBSnapshot)
-> Either String (Maybe ISO8601)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x [Node] -> Text -> Either String (Maybe ISO8601)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"OriginalSnapshotCreateTime")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"EngineVersion")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"Status")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"DBSnapshotArn")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Bool
      -> Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"MasterUsername")
      Either
  String
  (Maybe Text
   -> Maybe Bool
   -> Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Bool
      -> Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"SourceRegion")
      Either
  String
  (Maybe Bool
   -> Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Bool)
-> Either
     String
     (Maybe Int
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Bool)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"IAMDatabaseAuthenticationEnabled")
      Either
  String
  (Maybe Int
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe Text
      -> Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"Iops")
      Either
  String
  (Maybe Text
   -> Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe ISO8601
      -> Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"VpcId")
      Either
  String
  (Maybe ISO8601
   -> Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe ISO8601)
-> Either
     String
     (Maybe [Tag]
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe ISO8601)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"InstanceCreateTime")
      Either
  String
  (Maybe [Tag]
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe [Tag])
-> Either
     String
     (Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x [Node] -> Text -> Either String (Maybe [Node])
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"TagList" Either String (Maybe [Node]) -> [Node] -> Either String [Node]
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ [Node]
forall a. Monoid a => a
Prelude.mempty
                      Either String [Node]
-> ([Node] -> Either String (Maybe [Tag]))
-> Either String (Maybe [Tag])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= ([Node] -> Either String [Tag])
-> [Node] -> Either String (Maybe [Tag])
forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (Text -> [Node] -> Either String [Tag]
forall a. FromXML a => Text -> [Node] -> Either String [a]
Core.parseXMLList Text
"Tag")
                  )
      Either
  String
  (Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Bool
      -> Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"Engine")
      Either
  String
  (Maybe Bool
   -> Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Bool)
-> Either
     String
     (Maybe Text
      -> Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Bool)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"Encrypted")
      Either
  String
  (Maybe Text
   -> Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe [ProcessorFeature]
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"DBSnapshotIdentifier")
      Either
  String
  (Maybe [ProcessorFeature]
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe [ProcessorFeature])
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x [Node] -> Text -> Either String (Maybe [Node])
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"ProcessorFeatures"
                      Either String (Maybe [Node]) -> [Node] -> Either String [Node]
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ [Node]
forall a. Monoid a => a
Prelude.mempty
                      Either String [Node]
-> ([Node] -> Either String (Maybe [ProcessorFeature]))
-> Either String (Maybe [ProcessorFeature])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= ([Node] -> Either String [ProcessorFeature])
-> [Node] -> Either String (Maybe [ProcessorFeature])
forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (Text -> [Node] -> Either String [ProcessorFeature]
forall a. FromXML a => Text -> [Node] -> Either String [a]
Core.parseXMLList Text
"ProcessorFeature")
                  )
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"LicenseModel")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"SourceDBSnapshotIdentifier")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"SnapshotType")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"DBInstanceIdentifier")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"KmsKeyId")
      Either
  String
  (Maybe Text
   -> Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe ISO8601
      -> Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"AvailabilityZone")
      Either
  String
  (Maybe ISO8601
   -> Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe ISO8601)
-> Either
     String
     (Maybe Int
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe ISO8601)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"SnapshotCreateTime")
      Either
  String
  (Maybe Int
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"AllocatedStorage")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"DbiResourceId")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text
      -> Maybe Text
      -> Maybe Int
      -> Maybe Int
      -> Maybe Text
      -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"OptionGroupName")
      Either
  String
  (Maybe Text
   -> Maybe Text
   -> Maybe Int
   -> Maybe Int
   -> Maybe Text
   -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe Text -> Maybe Int -> Maybe Int -> Maybe Text -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"Timezone")
      Either
  String
  (Maybe Text -> Maybe Int -> Maybe Int -> Maybe Text -> DBSnapshot)
-> Either String (Maybe Text)
-> Either
     String (Maybe Int -> Maybe Int -> Maybe Text -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"TdeCredentialArn")
      Either String (Maybe Int -> Maybe Int -> Maybe Text -> DBSnapshot)
-> Either String (Maybe Int)
-> Either String (Maybe Int -> Maybe Text -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"PercentProgress")
      Either String (Maybe Int -> Maybe Text -> DBSnapshot)
-> Either String (Maybe Int)
-> Either String (Maybe Text -> DBSnapshot)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Int)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"Port")
      Either String (Maybe Text -> DBSnapshot)
-> Either String (Maybe Text) -> Either String DBSnapshot
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x [Node] -> Text -> Either String (Maybe Text)
forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Core..@? Text
"StorageType")

instance Prelude.Hashable DBSnapshot

instance Prelude.NFData DBSnapshot