{-# 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.Neptune.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.Neptune.Types.DBEngineVersion where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Neptune.Types.CharacterSet
import Amazonka.Neptune.Types.Timezone
import Amazonka.Neptune.Types.UpgradeTarget
import qualified Amazonka.Prelude as Prelude

-- | This data type is used as a response element in the action
-- DescribeDBEngineVersions.
--
-- /See:/ 'newDBEngineVersion' smart constructor.
data DBEngineVersion = DBEngineVersion'
  { -- | The description of the database engine.
    DBEngineVersion -> Maybe Text
dbEngineDescription :: 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,
    -- | /(Not supported by Neptune)/
    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],
    -- | /(Not supported by Neptune)/
    DBEngineVersion -> Maybe [CharacterSet]
supportedCharacterSets :: 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 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,
    -- | Indicates whether the database engine version supports read replicas.
    DBEngineVersion -> Maybe Bool
supportsReadReplica :: Prelude.Maybe Prelude.Bool,
    -- | 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:
--
-- 'dbEngineDescription', 'dbEngineVersion_dbEngineDescription' - The description of the database engine.
--
-- '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.
--
-- 'defaultCharacterSet', 'dbEngineVersion_defaultCharacterSet' - /(Not supported by Neptune)/
--
-- '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.
--
-- 'supportedCharacterSets', 'dbEngineVersion_supportedCharacterSets' - /(Not supported by Neptune)/
--
-- 'supportedTimezones', 'dbEngineVersion_supportedTimezones' - A list of the time zones supported by this engine for the @Timezone@
-- parameter of the @CreateDBInstance@ action.
--
-- '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.
--
-- 'supportsReadReplica', 'dbEngineVersion_supportsReadReplica' - Indicates whether the database engine version supports read replicas.
--
-- 'validUpgradeTarget', 'dbEngineVersion_validUpgradeTarget' - A list of engine versions that this database engine version can be
-- upgraded to.
newDBEngineVersion ::
  DBEngineVersion
newDBEngineVersion :: DBEngineVersion
newDBEngineVersion =
  DBEngineVersion'
    { $sel:dbEngineDescription:DBEngineVersion' :: Maybe Text
dbEngineDescription =
        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: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:supportedCharacterSets:DBEngineVersion' :: Maybe [CharacterSet]
supportedCharacterSets = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedTimezones:DBEngineVersion' :: Maybe [Timezone]
supportedTimezones = 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:supportsReadReplica:DBEngineVersion' :: Maybe Bool
supportsReadReplica = forall a. Maybe a
Prelude.Nothing,
      $sel:validUpgradeTarget:DBEngineVersion' :: Maybe [UpgradeTarget]
validUpgradeTarget = forall a. Maybe a
Prelude.Nothing
    }

-- | 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)

-- | 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)

-- | /(Not supported by Neptune)/
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

-- | /(Not supported by Neptune)/
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 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 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)

-- | 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)

-- | 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 Text
-> Maybe Text
-> Maybe Text
-> Maybe CharacterSet
-> Maybe Text
-> Maybe Text
-> Maybe [Text]
-> Maybe [CharacterSet]
-> Maybe [Timezone]
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> 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
"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
"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
"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
"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
"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
"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
"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
"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 [Timezone]
Maybe [UpgradeTarget]
Maybe Text
Maybe CharacterSet
validUpgradeTarget :: Maybe [UpgradeTarget]
supportsReadReplica :: Maybe Bool
supportsLogExportsToCloudwatchLogs :: Maybe Bool
supportsGlobalDatabases :: Maybe Bool
supportedTimezones :: Maybe [Timezone]
supportedCharacterSets :: Maybe [CharacterSet]
exportableLogTypes :: Maybe [Text]
engineVersion :: Maybe Text
engine :: Maybe Text
defaultCharacterSet :: Maybe CharacterSet
dbParameterGroupFamily :: Maybe Text
dbEngineVersionDescription :: Maybe Text
dbEngineDescription :: Maybe Text
$sel:validUpgradeTarget:DBEngineVersion' :: DBEngineVersion -> Maybe [UpgradeTarget]
$sel:supportsReadReplica:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsGlobalDatabases:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportedTimezones:DBEngineVersion' :: DBEngineVersion -> Maybe [Timezone]
$sel:supportedCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
$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:dbParameterGroupFamily:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineVersionDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbEngineDescription
      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 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 [CharacterSet]
supportedCharacterSets
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Timezone]
supportedTimezones
      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
supportsReadReplica
      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 [Timezone]
Maybe [UpgradeTarget]
Maybe Text
Maybe CharacterSet
validUpgradeTarget :: Maybe [UpgradeTarget]
supportsReadReplica :: Maybe Bool
supportsLogExportsToCloudwatchLogs :: Maybe Bool
supportsGlobalDatabases :: Maybe Bool
supportedTimezones :: Maybe [Timezone]
supportedCharacterSets :: Maybe [CharacterSet]
exportableLogTypes :: Maybe [Text]
engineVersion :: Maybe Text
engine :: Maybe Text
defaultCharacterSet :: Maybe CharacterSet
dbParameterGroupFamily :: Maybe Text
dbEngineVersionDescription :: Maybe Text
dbEngineDescription :: Maybe Text
$sel:validUpgradeTarget:DBEngineVersion' :: DBEngineVersion -> Maybe [UpgradeTarget]
$sel:supportsReadReplica:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsLogExportsToCloudwatchLogs:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportsGlobalDatabases:DBEngineVersion' :: DBEngineVersion -> Maybe Bool
$sel:supportedTimezones:DBEngineVersion' :: DBEngineVersion -> Maybe [Timezone]
$sel:supportedCharacterSets:DBEngineVersion' :: DBEngineVersion -> Maybe [CharacterSet]
$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:dbParameterGroupFamily:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineVersionDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
$sel:dbEngineDescription:DBEngineVersion' :: DBEngineVersion -> Maybe Text
..} =
    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
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 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 [CharacterSet]
supportedCharacterSets
      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
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
supportsReadReplica
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [UpgradeTarget]
validUpgradeTarget