{-# 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.DBEngineVersion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.RDS.Types.DBEngineVersion where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.RDS.Types.CharacterSet
import Amazonka.RDS.Types.CustomDBEngineVersionAMI
import Amazonka.RDS.Types.Tag
import Amazonka.RDS.Types.Timezone
import Amazonka.RDS.Types.UpgradeTarget

-- | This data type is used as a response element in the action
-- @DescribeDBEngineVersions@.
--
-- /See:/ 'newDBEngineVersion' smart constructor.
data DBEngineVersion = DBEngineVersion'
  { -- | The creation time of the DB engine version.
    DBEngineVersion -> Maybe ISO8601
createTime :: Prelude.Maybe Data.ISO8601,
    -- | JSON string that lists the installation files and parameters that RDS
    -- Custom uses to create a custom engine version (CEV). RDS Custom applies
    -- the patches in the order in which they\'re listed in the manifest. You
    -- can set the Oracle home, Oracle base, and UNIX\/Linux user and group
    -- using the installation parameters. For more information, see
    -- <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-cev.preparing.html#custom-cev.preparing.manifest.fields JSON fields in the CEV manifest>
    -- in the /Amazon RDS User Guide/.
    DBEngineVersion -> Maybe Text
customDBEngineVersionManifest :: Prelude.Maybe Prelude.Text,
    -- | The description of the database engine.
    DBEngineVersion -> Maybe Text
dbEngineDescription :: Prelude.Maybe Prelude.Text,
    -- | A value that indicates the source media provider of the AMI based on the
    -- usage operation. Applicable for RDS Custom for SQL Server.
    DBEngineVersion -> Maybe Text
dbEngineMediaType :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the custom engine version.
    DBEngineVersion -> Maybe Text
dbEngineVersionArn :: Prelude.Maybe Prelude.Text,
    -- | The description of the database engine version.
    DBEngineVersion -> Maybe Text
dbEngineVersionDescription :: Prelude.Maybe Prelude.Text,
    -- | The name of the DB parameter group family for the database engine.
    DBEngineVersion -> Maybe Text
dbParameterGroupFamily :: Prelude.Maybe Prelude.Text,
    -- | The name of the Amazon S3 bucket that contains your database
    -- installation files.
    DBEngineVersion -> Maybe Text
databaseInstallationFilesS3BucketName :: Prelude.Maybe Prelude.Text,
    -- | The Amazon S3 directory that contains the database installation files.
    -- If not specified, then no prefix is assumed.
    DBEngineVersion -> Maybe Text
databaseInstallationFilesS3Prefix :: Prelude.Maybe Prelude.Text,
    -- | The default character set for new instances of this engine version, if
    -- the @CharacterSetName@ parameter of the CreateDBInstance API isn\'t
    -- specified.
    DBEngineVersion -> Maybe CharacterSet
defaultCharacterSet :: Prelude.Maybe CharacterSet,
    -- | The name of the database engine.
    DBEngineVersion -> Maybe Text
engine :: Prelude.Maybe Prelude.Text,
    -- | The version number of the database engine.
    DBEngineVersion -> Maybe Text
engineVersion :: Prelude.Maybe Prelude.Text,
    -- | The types of logs that the database engine has available for export to
    -- CloudWatch Logs.
    DBEngineVersion -> Maybe [Text]
exportableLogTypes :: Prelude.Maybe [Prelude.Text],
    -- | The EC2 image
    DBEngineVersion -> Maybe CustomDBEngineVersionAMI
image :: Prelude.Maybe CustomDBEngineVersionAMI,
    -- | The Amazon Web Services KMS key identifier for an encrypted CEV. This
    -- parameter is required for RDS Custom, but optional for Amazon RDS.
    DBEngineVersion -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | The major engine version of the CEV.
    DBEngineVersion -> Maybe Text
majorEngineVersion :: Prelude.Maybe Prelude.Text,
    -- | The status of the DB engine version, either @available@ or @deprecated@.
    DBEngineVersion -> Maybe Text
status :: Prelude.Maybe Prelude.Text,
    -- | A list of the supported CA certificate identifiers.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html Using SSL\/TLS to encrypt a connection to a DB instance>
    -- in the /Amazon RDS User Guide/ and
    -- <https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.SSL.html Using SSL\/TLS to encrypt a connection to a DB cluster>
    -- in the /Amazon Aurora User Guide/.
    DBEngineVersion -> Maybe [Text]
supportedCACertificateIdentifiers :: Prelude.Maybe [Prelude.Text],
    -- | A list of the character sets supported by this engine for the
    -- @CharacterSetName@ parameter of the @CreateDBInstance@ operation.
    DBEngineVersion -> Maybe [CharacterSet]
supportedCharacterSets :: Prelude.Maybe [CharacterSet],
    -- | A list of the supported DB engine modes.
    DBEngineVersion -> Maybe [Text]
supportedEngineModes :: Prelude.Maybe [Prelude.Text],
    -- | A list of features supported by the DB engine.
    --
    -- The supported features vary by DB engine and DB engine version.
    --
    -- To determine the supported features for a specific DB engine and DB
    -- engine version using the CLI, use the following command:
    --
    -- @aws rds describe-db-engine-versions --engine \<engine_name> --engine-version \<engine_version>@
    --
    -- For example, to determine the supported features for RDS for PostgreSQL
    -- version 13.3 using the CLI, use the following command:
    --
    -- @aws rds describe-db-engine-versions --engine postgres --engine-version 13.3@
    --
    -- The supported features are listed under @SupportedFeatureNames@ in the
    -- output.
    DBEngineVersion -> Maybe [Text]
supportedFeatureNames :: Prelude.Maybe [Prelude.Text],
    -- | A list of the character sets supported by the Oracle DB engine for the
    -- @NcharCharacterSetName@ parameter of the @CreateDBInstance@ operation.
    DBEngineVersion -> Maybe [CharacterSet]
supportedNcharCharacterSets :: Prelude.Maybe [CharacterSet],
    -- | A list of the time zones supported by this engine for the @Timezone@
    -- parameter of the @CreateDBInstance@ action.
    DBEngineVersion -> Maybe [Timezone]
supportedTimezones :: Prelude.Maybe [Timezone],
    -- | A value that indicates whether the engine version supports Babelfish for
    -- Aurora PostgreSQL.
    DBEngineVersion -> Maybe Bool
supportsBabelfish :: Prelude.Maybe Prelude.Bool,
    -- | A value that indicates whether the engine version supports rotating the
    -- server certificate without rebooting the DB instance.
    DBEngineVersion -> Maybe Bool
supportsCertificateRotationWithoutRestart :: Prelude.Maybe Prelude.Bool,
    -- | A value that indicates whether you can use Aurora global databases with
    -- a specific DB engine version.
    DBEngineVersion -> Maybe Bool
supportsGlobalDatabases :: Prelude.Maybe Prelude.Bool,
    -- | A value that indicates whether the engine version supports exporting the
    -- log types specified by ExportableLogTypes to CloudWatch Logs.
    DBEngineVersion -> Maybe Bool
supportsLogExportsToCloudwatchLogs :: Prelude.Maybe Prelude.Bool,
    -- | A value that indicates whether you can use Aurora parallel query with a
    -- specific DB engine version.
    DBEngineVersion -> Maybe Bool
supportsParallelQuery :: Prelude.Maybe Prelude.Bool,
    -- | Indicates whether the database engine version supports read replicas.
    DBEngineVersion -> Maybe Bool
supportsReadReplica :: Prelude.Maybe Prelude.Bool,
    DBEngineVersion -> Maybe [Tag]
tagList :: Prelude.Maybe [Tag],
    -- | A list of engine versions that this database engine version can be
    -- upgraded to.
    DBEngineVersion -> Maybe [UpgradeTarget]
validUpgradeTarget :: Prelude.Maybe [UpgradeTarget]
  }
  deriving (DBEngineVersion -> DBEngineVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBEngineVersion -> DBEngineVersion -> Bool
$c/= :: DBEngineVersion -> DBEngineVersion -> Bool
== :: DBEngineVersion -> DBEngineVersion -> Bool
$c== :: DBEngineVersion -> DBEngineVersion -> Bool
Prelude.Eq, ReadPrec [DBEngineVersion]
ReadPrec DBEngineVersion
Int -> ReadS DBEngineVersion
ReadS [DBEngineVersion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DBEngineVersion]
$creadListPrec :: ReadPrec [DBEngineVersion]
readPrec :: ReadPrec DBEngineVersion
$creadPrec :: ReadPrec DBEngineVersion
readList :: ReadS [DBEngineVersion]
$creadList :: ReadS [DBEngineVersion]
readsPrec :: Int -> ReadS DBEngineVersion
$creadsPrec :: Int -> ReadS DBEngineVersion
Prelude.Read, Int -> DBEngineVersion -> ShowS
[DBEngineVersion] -> ShowS
DBEngineVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DBEngineVersion] -> ShowS
$cshowList :: [DBEngineVersion] -> ShowS
show :: DBEngineVersion -> String
$cshow :: DBEngineVersion -> String
showsPrec :: Int -> DBEngineVersion -> ShowS
$cshowsPrec :: Int -> DBEngineVersion -> ShowS
Prelude.Show, forall x. Rep DBEngineVersion x -> DBEngineVersion
forall x. DBEngineVersion -> Rep DBEngineVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DBEngineVersion x -> DBEngineVersion
$cfrom :: forall x. DBEngineVersion -> Rep DBEngineVersion x
Prelude.Generic)

-- |
-- Create a value of 'DBEngineVersion' 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:
--
-- 'createTime', 'dbEngineVersion_createTime' - The creation time of the DB engine version.
--
-- 'customDBEngineVersionManifest', 'dbEngineVersion_customDBEngineVersionManifest' - JSON string that lists the installation files and parameters that RDS
-- Custom uses to create a custom engine version (CEV). RDS Custom applies
-- the patches in the order in which they\'re listed in the manifest. You
-- can set the Oracle home, Oracle base, and UNIX\/Linux user and group
-- using the installation parameters. For more information, see
-- <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-cev.preparing.html#custom-cev.preparing.manifest.fields JSON fields in the CEV manifest>
-- in the /Amazon RDS User Guide/.
--
-- 'dbEngineDescription', 'dbEngineVersion_dbEngineDescription' - The description of the database engine.
--
-- 'dbEngineMediaType', 'dbEngineVersion_dbEngineMediaType' - A value that indicates the source media provider of the AMI based on the
-- usage operation. Applicable for RDS Custom for SQL Server.
--
-- 'dbEngineVersionArn', 'dbEngineVersion_dbEngineVersionArn' - The ARN of the custom engine version.
--
-- 'dbEngineVersionDescription', 'dbEngineVersion_dbEngineVersionDescription' - The description of the database engine version.
--
-- 'dbParameterGroupFamily', 'dbEngineVersion_dbParameterGroupFamily' - The name of the DB parameter group family for the database engine.
--
-- 'databaseInstallationFilesS3BucketName', 'dbEngineVersion_databaseInstallationFilesS3BucketName' - The name of the Amazon S3 bucket that contains your database
-- installation files.
--
-- 'databaseInstallationFilesS3Prefix', 'dbEngineVersion_databaseInstallationFilesS3Prefix' - The Amazon S3 directory that contains the database installation files.
-- If not specified, then no prefix is assumed.
--
-- 'defaultCharacterSet', 'dbEngineVersion_defaultCharacterSet' - The default character set for new instances of this engine version, if
-- the @CharacterSetName@ parameter of the CreateDBInstance API isn\'t
-- specified.
--
-- 'engine', 'dbEngineVersion_engine' - The name of the database engine.
--
-- 'engineVersion', 'dbEngineVersion_engineVersion' - The version number of the database engine.
--
-- 'exportableLogTypes', 'dbEngineVersion_exportableLogTypes' - The types of logs that the database engine has available for export to
-- CloudWatch Logs.
--
-- 'image', 'dbEngineVersion_image' - The EC2 image
--
-- 'kmsKeyId', 'dbEngineVersion_kmsKeyId' - The Amazon Web Services KMS key identifier for an encrypted CEV. This
-- parameter is required for RDS Custom, but optional for Amazon RDS.
--
-- 'majorEngineVersion', 'dbEngineVersion_majorEngineVersion' - The major engine version of the CEV.
--
-- 'status', 'dbEngineVersion_status' - The status of the DB engine version, either @available@ or @deprecated@.
--
-- 'supportedCACertificateIdentifiers', 'dbEngineVersion_supportedCACertificateIdentifiers' - A list of the supported CA certificate identifiers.
--
-- For more information, see
-- <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html Using SSL\/TLS to encrypt a connection to a DB instance>
-- in the /Amazon RDS User Guide/ and
-- <https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.SSL.html Using SSL\/TLS to encrypt a connection to a DB cluster>
-- in the /Amazon Aurora User Guide/.
--
-- 'supportedCharacterSets', 'dbEngineVersion_supportedCharacterSets' - A list of the character sets supported by this engine for the
-- @CharacterSetName@ parameter of the @CreateDBInstance@ operation.
--
-- 'supportedEngineModes', 'dbEngineVersion_supportedEngineModes' - A list of the supported DB engine modes.
--
-- 'supportedFeatureNames', 'dbEngineVersion_supportedFeatureNames' - A list of features supported by the DB engine.
--
-- The supported features vary by DB engine and DB engine version.
--
-- To determine the supported features for a specific DB engine and DB
-- engine version using the CLI, use the following command:
--
-- @aws rds describe-db-engine-versions --engine \<engine_name> --engine-version \<engine_version>@
--
-- For example, to determine the supported features for RDS for PostgreSQL
-- version 13.3 using the CLI, use the following command:
--
-- @aws rds describe-db-engine-versions --engine postgres --engine-version 13.3@
--
-- The supported features are listed under @SupportedFeatureNames@ in the
-- output.
--
-- 'supportedNcharCharacterSets', 'dbEngineVersion_supportedNcharCharacterSets' - A list of the character sets supported by the Oracle DB engine for the
-- @NcharCharacterSetName@ parameter of the @CreateDBInstance@ operation.
--
-- 'supportedTimezones', 'dbEngineVersion_supportedTimezones' - A list of the time zones supported by this engine for the @Timezone@
-- parameter of the @CreateDBInstance@ action.
--
-- 'supportsBabelfish', 'dbEngineVersion_supportsBabelfish' - A value that indicates whether the engine version supports Babelfish for
-- Aurora PostgreSQL.
--
-- 'supportsCertificateRotationWithoutRestart', 'dbEngineVersion_supportsCertificateRotationWithoutRestart' - A value that indicates whether the engine version supports rotating the
-- server certificate without rebooting the DB instance.
--
-- 'supportsGlobalDatabases', 'dbEngineVersion_supportsGlobalDatabases' - A value that indicates whether you can use Aurora global databases with
-- a specific DB engine version.
--
-- 'supportsLogExportsToCloudwatchLogs', 'dbEngineVersion_supportsLogExportsToCloudwatchLogs' - A value that indicates whether the engine version supports exporting the
-- log types specified by ExportableLogTypes to CloudWatch Logs.
--
-- 'supportsParallelQuery', 'dbEngineVersion_supportsParallelQuery' - A value that indicates whether you can use Aurora parallel query with a
-- specific DB engine version.
--
-- 'supportsReadReplica', 'dbEngineVersion_supportsReadReplica' - Indicates whether the database engine version supports read replicas.
--
-- 'tagList', 'dbEngineVersion_tagList' - Undocumented member.
--
-- 'validUpgradeTarget', 'dbEngineVersion_validUpgradeTarget' - A list of engine versions that this database engine version can be
-- upgraded to.
newDBEngineVersion ::
  DBEngineVersion
newDBEngineVersion :: DBEngineVersion
newDBEngineVersion =
  DBEngineVersion'
    { $sel:createTime:DBEngineVersion' :: Maybe ISO8601
createTime = forall a. Maybe a
Prelude.Nothing,
      $sel:customDBEngineVersionManifest:DBEngineVersion' :: Maybe Text
customDBEngineVersionManifest = forall a. Maybe a
Prelude.Nothing,
      $sel:dbEngineDescription:DBEngineVersion' :: Maybe Text
dbEngineDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:dbEngineMediaType:DBEngineVersion' :: Maybe Text
dbEngineMediaType = forall a. Maybe a
Prelude.Nothing,
      $sel:dbEngineVersionArn:DBEngineVersion' :: Maybe Text
dbEngineVersionArn = forall a. Maybe a
Prelude.Nothing,
      $sel:dbEngineVersionDescription:DBEngineVersion' :: Maybe Text
dbEngineVersionDescription = forall a. Maybe a
Prelude.Nothing,
      $sel:dbParameterGroupFamily:DBEngineVersion' :: Maybe Text
dbParameterGroupFamily = forall a. Maybe a
Prelude.Nothing,
      $sel:databaseInstallationFilesS3BucketName:DBEngineVersion' :: Maybe Text
databaseInstallationFilesS3BucketName =
        forall a. Maybe a
Prelude.Nothing,
      $sel:databaseInstallationFilesS3Prefix:DBEngineVersion' :: Maybe Text
databaseInstallationFilesS3Prefix = forall a. Maybe a
Prelude.Nothing,
      $sel:defaultCharacterSet:DBEngineVersion' :: Maybe CharacterSet
defaultCharacterSet = forall a. Maybe a
Prelude.Nothing,
      $sel:engine:DBEngineVersion' :: Maybe Text
engine = forall a. Maybe a
Prelude.Nothing,
      $sel:engineVersion:DBEngineVersion' :: Maybe Text
engineVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:exportableLogTypes:DBEngineVersion' :: Maybe [Text]
exportableLogTypes = forall a. Maybe a
Prelude.Nothing,
      $sel:image:DBEngineVersion' :: Maybe CustomDBEngineVersionAMI
image = forall a. Maybe a
Prelude.Nothing,
      $sel:kmsKeyId:DBEngineVersion' :: Maybe Text
kmsKeyId = forall a. Maybe a
Prelude.Nothing,
      $sel:majorEngineVersion:DBEngineVersion' :: Maybe Text
majorEngineVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:status:DBEngineVersion' :: Maybe Text
status = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedCACertificateIdentifiers:DBEngineVersion' :: Maybe [Text]
supportedCACertificateIdentifiers = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedCharacterSets:DBEngineVersion' :: Maybe [CharacterSet]
supportedCharacterSets = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedEngineModes:DBEngineVersion' :: Maybe [Text]
supportedEngineModes = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedFeatureNames:DBEngineVersion' :: Maybe [Text]
supportedFeatureNames = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedNcharCharacterSets:DBEngineVersion' :: Maybe [CharacterSet]
supportedNcharCharacterSets = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedTimezones:DBEngineVersion' :: Maybe [Timezone]
supportedTimezones = forall a. Maybe a
Prelude.Nothing,
      $sel:supportsBabelfish:DBEngineVersion' :: Maybe Bool
supportsBabelfish = forall a. Maybe a
Prelude.Nothing,
      $sel:supportsCertificateRotationWithoutRestart:DBEngineVersion' :: Maybe Bool
supportsCertificateRotationWithoutRestart =
        forall a. Maybe a
Prelude.Nothing,
      $sel:supportsGlobalDatabases:DBEngineVersion' :: Maybe Bool
supportsGlobalDatabases = forall a. Maybe a
Prelude.Nothing,
      $sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: Maybe Bool
supportsLogExportsToCloudwatchLogs = forall a. Maybe a
Prelude.Nothing,
      $sel:supportsParallelQuery:DBEngineVersion' :: Maybe Bool
supportsParallelQuery = forall a. Maybe a
Prelude.Nothing,
      $sel:supportsReadReplica:DBEngineVersion' :: Maybe Bool
supportsReadReplica = forall a. Maybe a
Prelude.Nothing,
      $sel:tagList:DBEngineVersion' :: Maybe [Tag]
tagList = forall a. Maybe a
Prelude.Nothing,
      $sel:validUpgradeTarget:DBEngineVersion' :: Maybe [UpgradeTarget]
validUpgradeTarget = forall a. Maybe a
Prelude.Nothing
    }

-- | The creation time of the DB engine version.
dbEngineVersion_createTime :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.UTCTime)
dbEngineVersion_createTime :: Lens' DBEngineVersion (Maybe UTCTime)
dbEngineVersion_createTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe ISO8601
createTime :: Maybe ISO8601
$sel:createTime:DBEngineVersion' :: DBEngineVersion -> Maybe ISO8601
createTime} -> Maybe ISO8601
createTime) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe ISO8601
a -> DBEngineVersion
s {$sel:createTime:DBEngineVersion' :: Maybe ISO8601
createTime = Maybe ISO8601
a} :: DBEngineVersion) 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

-- | JSON string that lists the installation files and parameters that RDS
-- Custom uses to create a custom engine version (CEV). RDS Custom applies
-- the patches in the order in which they\'re listed in the manifest. You
-- can set the Oracle home, Oracle base, and UNIX\/Linux user and group
-- using the installation parameters. For more information, see
-- <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-cev.preparing.html#custom-cev.preparing.manifest.fields JSON fields in the CEV manifest>
-- in the /Amazon RDS User Guide/.
dbEngineVersion_customDBEngineVersionManifest :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_customDBEngineVersionManifest :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_customDBEngineVersionManifest = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
customDBEngineVersionManifest :: Maybe Text
$sel:customDBEngineVersionManifest:DBEngineVersion' :: DBEngineVersion -> Maybe Text
customDBEngineVersionManifest} -> Maybe Text
customDBEngineVersionManifest) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:customDBEngineVersionManifest:DBEngineVersion' :: Maybe Text
customDBEngineVersionManifest = Maybe Text
a} :: DBEngineVersion)

-- | The description of the database engine.
dbEngineVersion_dbEngineDescription :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_dbEngineDescription :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_dbEngineDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
dbEngineDescription :: Maybe Text
$sel:dbEngineDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
dbEngineDescription} -> Maybe Text
dbEngineDescription) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:dbEngineDescription:DBEngineVersion' :: Maybe Text
dbEngineDescription = Maybe Text
a} :: DBEngineVersion)

-- | A value that indicates the source media provider of the AMI based on the
-- usage operation. Applicable for RDS Custom for SQL Server.
dbEngineVersion_dbEngineMediaType :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_dbEngineMediaType :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_dbEngineMediaType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
dbEngineMediaType :: Maybe Text
$sel:dbEngineMediaType:DBEngineVersion' :: DBEngineVersion -> Maybe Text
dbEngineMediaType} -> Maybe Text
dbEngineMediaType) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:dbEngineMediaType:DBEngineVersion' :: Maybe Text
dbEngineMediaType = Maybe Text
a} :: DBEngineVersion)

-- | The ARN of the custom engine version.
dbEngineVersion_dbEngineVersionArn :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_dbEngineVersionArn :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_dbEngineVersionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
dbEngineVersionArn :: Maybe Text
$sel:dbEngineVersionArn:DBEngineVersion' :: DBEngineVersion -> Maybe Text
dbEngineVersionArn} -> Maybe Text
dbEngineVersionArn) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:dbEngineVersionArn:DBEngineVersion' :: Maybe Text
dbEngineVersionArn = Maybe Text
a} :: DBEngineVersion)

-- | The description of the database engine version.
dbEngineVersion_dbEngineVersionDescription :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_dbEngineVersionDescription :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_dbEngineVersionDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
dbEngineVersionDescription :: Maybe Text
$sel:dbEngineVersionDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
dbEngineVersionDescription} -> Maybe Text
dbEngineVersionDescription) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:dbEngineVersionDescription:DBEngineVersion' :: Maybe Text
dbEngineVersionDescription = Maybe Text
a} :: DBEngineVersion)

-- | The name of the DB parameter group family for the database engine.
dbEngineVersion_dbParameterGroupFamily :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_dbParameterGroupFamily :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_dbParameterGroupFamily = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
dbParameterGroupFamily :: Maybe Text
$sel:dbParameterGroupFamily:DBEngineVersion' :: DBEngineVersion -> Maybe Text
dbParameterGroupFamily} -> Maybe Text
dbParameterGroupFamily) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:dbParameterGroupFamily:DBEngineVersion' :: Maybe Text
dbParameterGroupFamily = Maybe Text
a} :: DBEngineVersion)

-- | The name of the Amazon S3 bucket that contains your database
-- installation files.
dbEngineVersion_databaseInstallationFilesS3BucketName :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_databaseInstallationFilesS3BucketName :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_databaseInstallationFilesS3BucketName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
databaseInstallationFilesS3BucketName :: Maybe Text
$sel:databaseInstallationFilesS3BucketName:DBEngineVersion' :: DBEngineVersion -> Maybe Text
databaseInstallationFilesS3BucketName} -> Maybe Text
databaseInstallationFilesS3BucketName) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:databaseInstallationFilesS3BucketName:DBEngineVersion' :: Maybe Text
databaseInstallationFilesS3BucketName = Maybe Text
a} :: DBEngineVersion)

-- | The Amazon S3 directory that contains the database installation files.
-- If not specified, then no prefix is assumed.
dbEngineVersion_databaseInstallationFilesS3Prefix :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_databaseInstallationFilesS3Prefix :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_databaseInstallationFilesS3Prefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
databaseInstallationFilesS3Prefix :: Maybe Text
$sel:databaseInstallationFilesS3Prefix:DBEngineVersion' :: DBEngineVersion -> Maybe Text
databaseInstallationFilesS3Prefix} -> Maybe Text
databaseInstallationFilesS3Prefix) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:databaseInstallationFilesS3Prefix:DBEngineVersion' :: Maybe Text
databaseInstallationFilesS3Prefix = Maybe Text
a} :: DBEngineVersion)

-- | The default character set for new instances of this engine version, if
-- the @CharacterSetName@ parameter of the CreateDBInstance API isn\'t
-- specified.
dbEngineVersion_defaultCharacterSet :: Lens.Lens' DBEngineVersion (Prelude.Maybe CharacterSet)
dbEngineVersion_defaultCharacterSet :: Lens' DBEngineVersion (Maybe CharacterSet)
dbEngineVersion_defaultCharacterSet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe CharacterSet
defaultCharacterSet :: Maybe CharacterSet
$sel:defaultCharacterSet:DBEngineVersion' :: DBEngineVersion -> Maybe CharacterSet
defaultCharacterSet} -> Maybe CharacterSet
defaultCharacterSet) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe CharacterSet
a -> DBEngineVersion
s {$sel:defaultCharacterSet:DBEngineVersion' :: Maybe CharacterSet
defaultCharacterSet = Maybe CharacterSet
a} :: DBEngineVersion)

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

-- | The version number of the database engine.
dbEngineVersion_engineVersion :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_engineVersion :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_engineVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
engineVersion :: Maybe Text
$sel:engineVersion:DBEngineVersion' :: DBEngineVersion -> Maybe Text
engineVersion} -> Maybe Text
engineVersion) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:engineVersion:DBEngineVersion' :: Maybe Text
engineVersion = Maybe Text
a} :: DBEngineVersion)

-- | The types of logs that the database engine has available for export to
-- CloudWatch Logs.
dbEngineVersion_exportableLogTypes :: Lens.Lens' DBEngineVersion (Prelude.Maybe [Prelude.Text])
dbEngineVersion_exportableLogTypes :: Lens' DBEngineVersion (Maybe [Text])
dbEngineVersion_exportableLogTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [Text]
exportableLogTypes :: Maybe [Text]
$sel:exportableLogTypes:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
exportableLogTypes} -> Maybe [Text]
exportableLogTypes) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [Text]
a -> DBEngineVersion
s {$sel:exportableLogTypes:DBEngineVersion' :: Maybe [Text]
exportableLogTypes = Maybe [Text]
a} :: DBEngineVersion) 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 EC2 image
dbEngineVersion_image :: Lens.Lens' DBEngineVersion (Prelude.Maybe CustomDBEngineVersionAMI)
dbEngineVersion_image :: Lens' DBEngineVersion (Maybe CustomDBEngineVersionAMI)
dbEngineVersion_image = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe CustomDBEngineVersionAMI
image :: Maybe CustomDBEngineVersionAMI
$sel:image:DBEngineVersion' :: DBEngineVersion -> Maybe CustomDBEngineVersionAMI
image} -> Maybe CustomDBEngineVersionAMI
image) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe CustomDBEngineVersionAMI
a -> DBEngineVersion
s {$sel:image:DBEngineVersion' :: Maybe CustomDBEngineVersionAMI
image = Maybe CustomDBEngineVersionAMI
a} :: DBEngineVersion)

-- | The Amazon Web Services KMS key identifier for an encrypted CEV. This
-- parameter is required for RDS Custom, but optional for Amazon RDS.
dbEngineVersion_kmsKeyId :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_kmsKeyId :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_kmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:DBEngineVersion' :: DBEngineVersion -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:kmsKeyId:DBEngineVersion' :: Maybe Text
kmsKeyId = Maybe Text
a} :: DBEngineVersion)

-- | The major engine version of the CEV.
dbEngineVersion_majorEngineVersion :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_majorEngineVersion :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_majorEngineVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
majorEngineVersion :: Maybe Text
$sel:majorEngineVersion:DBEngineVersion' :: DBEngineVersion -> Maybe Text
majorEngineVersion} -> Maybe Text
majorEngineVersion) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:majorEngineVersion:DBEngineVersion' :: Maybe Text
majorEngineVersion = Maybe Text
a} :: DBEngineVersion)

-- | The status of the DB engine version, either @available@ or @deprecated@.
dbEngineVersion_status :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Text)
dbEngineVersion_status :: Lens' DBEngineVersion (Maybe Text)
dbEngineVersion_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Text
status :: Maybe Text
$sel:status:DBEngineVersion' :: DBEngineVersion -> Maybe Text
status} -> Maybe Text
status) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Text
a -> DBEngineVersion
s {$sel:status:DBEngineVersion' :: Maybe Text
status = Maybe Text
a} :: DBEngineVersion)

-- | A list of the supported CA certificate identifiers.
--
-- For more information, see
-- <https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html Using SSL\/TLS to encrypt a connection to a DB instance>
-- in the /Amazon RDS User Guide/ and
-- <https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.SSL.html Using SSL\/TLS to encrypt a connection to a DB cluster>
-- in the /Amazon Aurora User Guide/.
dbEngineVersion_supportedCACertificateIdentifiers :: Lens.Lens' DBEngineVersion (Prelude.Maybe [Prelude.Text])
dbEngineVersion_supportedCACertificateIdentifiers :: Lens' DBEngineVersion (Maybe [Text])
dbEngineVersion_supportedCACertificateIdentifiers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [Text]
supportedCACertificateIdentifiers :: Maybe [Text]
$sel:supportedCACertificateIdentifiers:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
supportedCACertificateIdentifiers} -> Maybe [Text]
supportedCACertificateIdentifiers) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [Text]
a -> DBEngineVersion
s {$sel:supportedCACertificateIdentifiers:DBEngineVersion' :: Maybe [Text]
supportedCACertificateIdentifiers = Maybe [Text]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the character sets supported by this engine for the
-- @CharacterSetName@ parameter of the @CreateDBInstance@ operation.
dbEngineVersion_supportedCharacterSets :: Lens.Lens' DBEngineVersion (Prelude.Maybe [CharacterSet])
dbEngineVersion_supportedCharacterSets :: Lens' DBEngineVersion (Maybe [CharacterSet])
dbEngineVersion_supportedCharacterSets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [CharacterSet]
supportedCharacterSets :: Maybe [CharacterSet]
$sel:supportedCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
supportedCharacterSets} -> Maybe [CharacterSet]
supportedCharacterSets) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [CharacterSet]
a -> DBEngineVersion
s {$sel:supportedCharacterSets:DBEngineVersion' :: Maybe [CharacterSet]
supportedCharacterSets = Maybe [CharacterSet]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the supported DB engine modes.
dbEngineVersion_supportedEngineModes :: Lens.Lens' DBEngineVersion (Prelude.Maybe [Prelude.Text])
dbEngineVersion_supportedEngineModes :: Lens' DBEngineVersion (Maybe [Text])
dbEngineVersion_supportedEngineModes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [Text]
supportedEngineModes :: Maybe [Text]
$sel:supportedEngineModes:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
supportedEngineModes} -> Maybe [Text]
supportedEngineModes) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [Text]
a -> DBEngineVersion
s {$sel:supportedEngineModes:DBEngineVersion' :: Maybe [Text]
supportedEngineModes = Maybe [Text]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of features supported by the DB engine.
--
-- The supported features vary by DB engine and DB engine version.
--
-- To determine the supported features for a specific DB engine and DB
-- engine version using the CLI, use the following command:
--
-- @aws rds describe-db-engine-versions --engine \<engine_name> --engine-version \<engine_version>@
--
-- For example, to determine the supported features for RDS for PostgreSQL
-- version 13.3 using the CLI, use the following command:
--
-- @aws rds describe-db-engine-versions --engine postgres --engine-version 13.3@
--
-- The supported features are listed under @SupportedFeatureNames@ in the
-- output.
dbEngineVersion_supportedFeatureNames :: Lens.Lens' DBEngineVersion (Prelude.Maybe [Prelude.Text])
dbEngineVersion_supportedFeatureNames :: Lens' DBEngineVersion (Maybe [Text])
dbEngineVersion_supportedFeatureNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [Text]
supportedFeatureNames :: Maybe [Text]
$sel:supportedFeatureNames:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
supportedFeatureNames} -> Maybe [Text]
supportedFeatureNames) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [Text]
a -> DBEngineVersion
s {$sel:supportedFeatureNames:DBEngineVersion' :: Maybe [Text]
supportedFeatureNames = Maybe [Text]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the character sets supported by the Oracle DB engine for the
-- @NcharCharacterSetName@ parameter of the @CreateDBInstance@ operation.
dbEngineVersion_supportedNcharCharacterSets :: Lens.Lens' DBEngineVersion (Prelude.Maybe [CharacterSet])
dbEngineVersion_supportedNcharCharacterSets :: Lens' DBEngineVersion (Maybe [CharacterSet])
dbEngineVersion_supportedNcharCharacterSets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [CharacterSet]
supportedNcharCharacterSets :: Maybe [CharacterSet]
$sel:supportedNcharCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
supportedNcharCharacterSets} -> Maybe [CharacterSet]
supportedNcharCharacterSets) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [CharacterSet]
a -> DBEngineVersion
s {$sel:supportedNcharCharacterSets:DBEngineVersion' :: Maybe [CharacterSet]
supportedNcharCharacterSets = Maybe [CharacterSet]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of the time zones supported by this engine for the @Timezone@
-- parameter of the @CreateDBInstance@ action.
dbEngineVersion_supportedTimezones :: Lens.Lens' DBEngineVersion (Prelude.Maybe [Timezone])
dbEngineVersion_supportedTimezones :: Lens' DBEngineVersion (Maybe [Timezone])
dbEngineVersion_supportedTimezones = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [Timezone]
supportedTimezones :: Maybe [Timezone]
$sel:supportedTimezones:DBEngineVersion' :: DBEngineVersion -> Maybe [Timezone]
supportedTimezones} -> Maybe [Timezone]
supportedTimezones) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [Timezone]
a -> DBEngineVersion
s {$sel:supportedTimezones:DBEngineVersion' :: Maybe [Timezone]
supportedTimezones = Maybe [Timezone]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A value that indicates whether the engine version supports Babelfish for
-- Aurora PostgreSQL.
dbEngineVersion_supportsBabelfish :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Bool)
dbEngineVersion_supportsBabelfish :: Lens' DBEngineVersion (Maybe Bool)
dbEngineVersion_supportsBabelfish = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Bool
supportsBabelfish :: Maybe Bool
$sel:supportsBabelfish:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
supportsBabelfish} -> Maybe Bool
supportsBabelfish) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Bool
a -> DBEngineVersion
s {$sel:supportsBabelfish:DBEngineVersion' :: Maybe Bool
supportsBabelfish = Maybe Bool
a} :: DBEngineVersion)

-- | A value that indicates whether the engine version supports rotating the
-- server certificate without rebooting the DB instance.
dbEngineVersion_supportsCertificateRotationWithoutRestart :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Bool)
dbEngineVersion_supportsCertificateRotationWithoutRestart :: Lens' DBEngineVersion (Maybe Bool)
dbEngineVersion_supportsCertificateRotationWithoutRestart = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Bool
supportsCertificateRotationWithoutRestart :: Maybe Bool
$sel:supportsCertificateRotationWithoutRestart:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
supportsCertificateRotationWithoutRestart} -> Maybe Bool
supportsCertificateRotationWithoutRestart) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Bool
a -> DBEngineVersion
s {$sel:supportsCertificateRotationWithoutRestart:DBEngineVersion' :: Maybe Bool
supportsCertificateRotationWithoutRestart = Maybe Bool
a} :: DBEngineVersion)

-- | A value that indicates whether you can use Aurora global databases with
-- a specific DB engine version.
dbEngineVersion_supportsGlobalDatabases :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Bool)
dbEngineVersion_supportsGlobalDatabases :: Lens' DBEngineVersion (Maybe Bool)
dbEngineVersion_supportsGlobalDatabases = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Bool
supportsGlobalDatabases :: Maybe Bool
$sel:supportsGlobalDatabases:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
supportsGlobalDatabases} -> Maybe Bool
supportsGlobalDatabases) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Bool
a -> DBEngineVersion
s {$sel:supportsGlobalDatabases:DBEngineVersion' :: Maybe Bool
supportsGlobalDatabases = Maybe Bool
a} :: DBEngineVersion)

-- | A value that indicates whether the engine version supports exporting the
-- log types specified by ExportableLogTypes to CloudWatch Logs.
dbEngineVersion_supportsLogExportsToCloudwatchLogs :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Bool)
dbEngineVersion_supportsLogExportsToCloudwatchLogs :: Lens' DBEngineVersion (Maybe Bool)
dbEngineVersion_supportsLogExportsToCloudwatchLogs = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Bool
supportsLogExportsToCloudwatchLogs :: Maybe Bool
$sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
supportsLogExportsToCloudwatchLogs} -> Maybe Bool
supportsLogExportsToCloudwatchLogs) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Bool
a -> DBEngineVersion
s {$sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: Maybe Bool
supportsLogExportsToCloudwatchLogs = Maybe Bool
a} :: DBEngineVersion)

-- | A value that indicates whether you can use Aurora parallel query with a
-- specific DB engine version.
dbEngineVersion_supportsParallelQuery :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Bool)
dbEngineVersion_supportsParallelQuery :: Lens' DBEngineVersion (Maybe Bool)
dbEngineVersion_supportsParallelQuery = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Bool
supportsParallelQuery :: Maybe Bool
$sel:supportsParallelQuery:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
supportsParallelQuery} -> Maybe Bool
supportsParallelQuery) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Bool
a -> DBEngineVersion
s {$sel:supportsParallelQuery:DBEngineVersion' :: Maybe Bool
supportsParallelQuery = Maybe Bool
a} :: DBEngineVersion)

-- | Indicates whether the database engine version supports read replicas.
dbEngineVersion_supportsReadReplica :: Lens.Lens' DBEngineVersion (Prelude.Maybe Prelude.Bool)
dbEngineVersion_supportsReadReplica :: Lens' DBEngineVersion (Maybe Bool)
dbEngineVersion_supportsReadReplica = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe Bool
supportsReadReplica :: Maybe Bool
$sel:supportsReadReplica:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
supportsReadReplica} -> Maybe Bool
supportsReadReplica) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe Bool
a -> DBEngineVersion
s {$sel:supportsReadReplica:DBEngineVersion' :: Maybe Bool
supportsReadReplica = Maybe Bool
a} :: DBEngineVersion)

-- | Undocumented member.
dbEngineVersion_tagList :: Lens.Lens' DBEngineVersion (Prelude.Maybe [Tag])
dbEngineVersion_tagList :: Lens' DBEngineVersion (Maybe [Tag])
dbEngineVersion_tagList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [Tag]
tagList :: Maybe [Tag]
$sel:tagList:DBEngineVersion' :: DBEngineVersion -> Maybe [Tag]
tagList} -> Maybe [Tag]
tagList) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [Tag]
a -> DBEngineVersion
s {$sel:tagList:DBEngineVersion' :: Maybe [Tag]
tagList = Maybe [Tag]
a} :: DBEngineVersion) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of engine versions that this database engine version can be
-- upgraded to.
dbEngineVersion_validUpgradeTarget :: Lens.Lens' DBEngineVersion (Prelude.Maybe [UpgradeTarget])
dbEngineVersion_validUpgradeTarget :: Lens' DBEngineVersion (Maybe [UpgradeTarget])
dbEngineVersion_validUpgradeTarget = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DBEngineVersion' {Maybe [UpgradeTarget]
validUpgradeTarget :: Maybe [UpgradeTarget]
$sel:validUpgradeTarget:DBEngineVersion' :: DBEngineVersion -> Maybe [UpgradeTarget]
validUpgradeTarget} -> Maybe [UpgradeTarget]
validUpgradeTarget) (\s :: DBEngineVersion
s@DBEngineVersion' {} Maybe [UpgradeTarget]
a -> DBEngineVersion
s {$sel:validUpgradeTarget:DBEngineVersion' :: Maybe [UpgradeTarget]
validUpgradeTarget = Maybe [UpgradeTarget]
a} :: DBEngineVersion) 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

instance Data.FromXML DBEngineVersion where
  parseXML :: [Node] -> Either String DBEngineVersion
parseXML [Node]
x =
    Maybe ISO8601
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe CharacterSet
-> Maybe Text
-> Maybe Text
-> Maybe [Text]
-> Maybe CustomDBEngineVersionAMI
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [Text]
-> Maybe [CharacterSet]
-> Maybe [Text]
-> Maybe [Text]
-> Maybe [CharacterSet]
-> Maybe [Timezone]
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe [Tag]
-> Maybe [UpgradeTarget]
-> DBEngineVersion
DBEngineVersion'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"CreateTime")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"CustomDBEngineVersionManifest")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DBEngineDescription")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DBEngineMediaType")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DBEngineVersionArn")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DBEngineVersionDescription")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DBParameterGroupFamily")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DatabaseInstallationFilesS3BucketName")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DatabaseInstallationFilesS3Prefix")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"DefaultCharacterSet")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Engine")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"EngineVersion")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ExportableLogTypes"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Image")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"KMSKeyId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"MajorEngineVersion")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Status")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportedCACertificateIdentifiers"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportedCharacterSets"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"CharacterSet")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportedEngineModes"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportedFeatureNames"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportedNcharCharacterSets"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"CharacterSet")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportedTimezones"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"Timezone")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportsBabelfish")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportsCertificateRotationWithoutRestart"
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportsGlobalDatabases")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportsLogExportsToCloudwatchLogs")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportsParallelQuery")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"SupportsReadReplica")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"TagList"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"Tag")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ValidUpgradeTarget"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"UpgradeTarget")
                  )

instance Prelude.Hashable DBEngineVersion where
  hashWithSalt :: Int -> DBEngineVersion -> Int
hashWithSalt Int
_salt DBEngineVersion' {Maybe Bool
Maybe [Text]
Maybe [CharacterSet]
Maybe [Tag]
Maybe [Timezone]
Maybe [UpgradeTarget]
Maybe Text
Maybe ISO8601
Maybe CharacterSet
Maybe CustomDBEngineVersionAMI
validUpgradeTarget :: Maybe [UpgradeTarget]
tagList :: Maybe [Tag]
supportsReadReplica :: Maybe Bool
supportsParallelQuery :: Maybe Bool
supportsLogExportsToCloudwatchLogs :: Maybe Bool
supportsGlobalDatabases :: Maybe Bool
supportsCertificateRotationWithoutRestart :: Maybe Bool
supportsBabelfish :: Maybe Bool
supportedTimezones :: Maybe [Timezone]
supportedNcharCharacterSets :: Maybe [CharacterSet]
supportedFeatureNames :: Maybe [Text]
supportedEngineModes :: Maybe [Text]
supportedCharacterSets :: Maybe [CharacterSet]
supportedCACertificateIdentifiers :: Maybe [Text]
status :: Maybe Text
majorEngineVersion :: Maybe Text
kmsKeyId :: Maybe Text
image :: Maybe CustomDBEngineVersionAMI
exportableLogTypes :: Maybe [Text]
engineVersion :: Maybe Text
engine :: Maybe Text
defaultCharacterSet :: Maybe CharacterSet
databaseInstallationFilesS3Prefix :: Maybe Text
databaseInstallationFilesS3BucketName :: Maybe Text
dbParameterGroupFamily :: Maybe Text
dbEngineVersionDescription :: Maybe Text
dbEngineVersionArn :: Maybe Text
dbEngineMediaType :: Maybe Text
dbEngineDescription :: Maybe Text
customDBEngineVersionManifest :: Maybe Text
createTime :: Maybe ISO8601
$sel:validUpgradeTarget:DBEngineVersion' :: DBEngineVersion -> Maybe [UpgradeTarget]
$sel:tagList:DBEngineVersion' :: DBEngineVersion -> Maybe [Tag]
$sel:supportsReadReplica:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsParallelQuery:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsGlobalDatabases:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsCertificateRotationWithoutRestart:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsBabelfish:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportedTimezones:DBEngineVersion' :: DBEngineVersion -> Maybe [Timezone]
$sel:supportedNcharCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
$sel:supportedFeatureNames:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:supportedEngineModes:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:supportedCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
$sel:supportedCACertificateIdentifiers:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:status:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:majorEngineVersion:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:kmsKeyId:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:image:DBEngineVersion' :: DBEngineVersion -> Maybe CustomDBEngineVersionAMI
$sel:exportableLogTypes:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:engineVersion:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:engine:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:defaultCharacterSet:DBEngineVersion' :: DBEngineVersion -> Maybe CharacterSet
$sel:databaseInstallationFilesS3Prefix:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:databaseInstallationFilesS3BucketName:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbParameterGroupFamily:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineVersionDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineVersionArn:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineMediaType:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:customDBEngineVersionManifest:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:createTime:DBEngineVersion' :: DBEngineVersion -> Maybe ISO8601
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
createTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
customDBEngineVersionManifest
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbEngineDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbEngineMediaType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbEngineVersionArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbEngineVersionDescription
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbParameterGroupFamily
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
databaseInstallationFilesS3BucketName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
databaseInstallationFilesS3Prefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CharacterSet
defaultCharacterSet
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
engine
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
engineVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
exportableLogTypes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CustomDBEngineVersionAMI
image
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
kmsKeyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
majorEngineVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
supportedCACertificateIdentifiers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CharacterSet]
supportedCharacterSets
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
supportedEngineModes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
supportedFeatureNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [CharacterSet]
supportedNcharCharacterSets
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Timezone]
supportedTimezones
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
supportsBabelfish
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
supportsCertificateRotationWithoutRestart
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
supportsGlobalDatabases
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
supportsLogExportsToCloudwatchLogs
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
supportsParallelQuery
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
supportsReadReplica
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tagList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [UpgradeTarget]
validUpgradeTarget

instance Prelude.NFData DBEngineVersion where
  rnf :: DBEngineVersion -> ()
rnf DBEngineVersion' {Maybe Bool
Maybe [Text]
Maybe [CharacterSet]
Maybe [Tag]
Maybe [Timezone]
Maybe [UpgradeTarget]
Maybe Text
Maybe ISO8601
Maybe CharacterSet
Maybe CustomDBEngineVersionAMI
validUpgradeTarget :: Maybe [UpgradeTarget]
tagList :: Maybe [Tag]
supportsReadReplica :: Maybe Bool
supportsParallelQuery :: Maybe Bool
supportsLogExportsToCloudwatchLogs :: Maybe Bool
supportsGlobalDatabases :: Maybe Bool
supportsCertificateRotationWithoutRestart :: Maybe Bool
supportsBabelfish :: Maybe Bool
supportedTimezones :: Maybe [Timezone]
supportedNcharCharacterSets :: Maybe [CharacterSet]
supportedFeatureNames :: Maybe [Text]
supportedEngineModes :: Maybe [Text]
supportedCharacterSets :: Maybe [CharacterSet]
supportedCACertificateIdentifiers :: Maybe [Text]
status :: Maybe Text
majorEngineVersion :: Maybe Text
kmsKeyId :: Maybe Text
image :: Maybe CustomDBEngineVersionAMI
exportableLogTypes :: Maybe [Text]
engineVersion :: Maybe Text
engine :: Maybe Text
defaultCharacterSet :: Maybe CharacterSet
databaseInstallationFilesS3Prefix :: Maybe Text
databaseInstallationFilesS3BucketName :: Maybe Text
dbParameterGroupFamily :: Maybe Text
dbEngineVersionDescription :: Maybe Text
dbEngineVersionArn :: Maybe Text
dbEngineMediaType :: Maybe Text
dbEngineDescription :: Maybe Text
customDBEngineVersionManifest :: Maybe Text
createTime :: Maybe ISO8601
$sel:validUpgradeTarget:DBEngineVersion' :: DBEngineVersion -> Maybe [UpgradeTarget]
$sel:tagList:DBEngineVersion' :: DBEngineVersion -> Maybe [Tag]
$sel:supportsReadReplica:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsParallelQuery:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsGlobalDatabases:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsCertificateRotationWithoutRestart:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsBabelfish:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportedTimezones:DBEngineVersion' :: DBEngineVersion -> Maybe [Timezone]
$sel:supportedNcharCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
$sel:supportedFeatureNames:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:supportedEngineModes:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:supportedCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
$sel:supportedCACertificateIdentifiers:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:status:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:majorEngineVersion:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:kmsKeyId:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:image:DBEngineVersion' :: DBEngineVersion -> Maybe CustomDBEngineVersionAMI
$sel:exportableLogTypes:DBEngineVersion' :: DBEngineVersion -> Maybe [Text]
$sel:engineVersion:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:engine:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:defaultCharacterSet:DBEngineVersion' :: DBEngineVersion -> Maybe CharacterSet
$sel:databaseInstallationFilesS3Prefix:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:databaseInstallationFilesS3BucketName:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbParameterGroupFamily:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineVersionDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineVersionArn:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineMediaType:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:customDBEngineVersionManifest:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:createTime:DBEngineVersion' :: DBEngineVersion -> Maybe ISO8601
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
createTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
customDBEngineVersionManifest
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbEngineDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbEngineMediaType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbEngineVersionArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbEngineVersionDescription
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbParameterGroupFamily
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
databaseInstallationFilesS3BucketName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
databaseInstallationFilesS3Prefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CharacterSet
defaultCharacterSet
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
engine
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
engineVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
exportableLogTypes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CustomDBEngineVersionAMI
image
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
kmsKeyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
majorEngineVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [Text]
supportedCACertificateIdentifiers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [CharacterSet]
supportedCharacterSets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [Text]
supportedEngineModes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [Text]
supportedFeatureNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [CharacterSet]
supportedNcharCharacterSets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [Timezone]
supportedTimezones
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Bool
supportsBabelfish
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Bool
supportsCertificateRotationWithoutRestart
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Bool
supportsGlobalDatabases
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Bool
supportsLogExportsToCloudwatchLogs
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Bool
supportsParallelQuery
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Bool
supportsReadReplica
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [Tag]
tagList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [UpgradeTarget]
validUpgradeTarget