{-# 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.OpenSearch.Types.DomainStatus
-- 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.OpenSearch.Types.DomainStatus where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.OpenSearch.Types.AdvancedSecurityOptions
import Amazonka.OpenSearch.Types.AutoTuneOptionsOutput
import Amazonka.OpenSearch.Types.ChangeProgressDetails
import Amazonka.OpenSearch.Types.ClusterConfig
import Amazonka.OpenSearch.Types.CognitoOptions
import Amazonka.OpenSearch.Types.DomainEndpointOptions
import Amazonka.OpenSearch.Types.EBSOptions
import Amazonka.OpenSearch.Types.EncryptionAtRestOptions
import Amazonka.OpenSearch.Types.LogPublishingOption
import Amazonka.OpenSearch.Types.LogType
import Amazonka.OpenSearch.Types.NodeToNodeEncryptionOptions
import Amazonka.OpenSearch.Types.ServiceSoftwareOptions
import Amazonka.OpenSearch.Types.SnapshotOptions
import Amazonka.OpenSearch.Types.VPCDerivedInfo
import qualified Amazonka.Prelude as Prelude

-- | The current status of an OpenSearch Service domain.
--
-- /See:/ 'newDomainStatus' smart constructor.
data DomainStatus = DomainStatus'
  { -- | Identity and Access Management (IAM) policy document specifying the
    -- access policies for the domain.
    DomainStatus -> Maybe Text
accessPolicies :: Prelude.Maybe Prelude.Text,
    -- | Key-value pairs that specify advanced configuration options.
    DomainStatus -> Maybe (HashMap Text Text)
advancedOptions :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Settings for fine-grained access control.
    DomainStatus -> Maybe AdvancedSecurityOptions
advancedSecurityOptions :: Prelude.Maybe AdvancedSecurityOptions,
    -- | Auto-Tune settings for the domain.
    DomainStatus -> Maybe AutoTuneOptionsOutput
autoTuneOptions :: Prelude.Maybe AutoTuneOptionsOutput,
    -- | Information about a configuration change happening on the domain.
    DomainStatus -> Maybe ChangeProgressDetails
changeProgressDetails :: Prelude.Maybe ChangeProgressDetails,
    -- | Key-value pairs to configure Amazon Cognito authentication for
    -- OpenSearch Dashboards.
    DomainStatus -> Maybe CognitoOptions
cognitoOptions :: Prelude.Maybe CognitoOptions,
    -- | Creation status of an OpenSearch Service domain. True if domain creation
    -- is complete. False if domain creation is still in progress.
    DomainStatus -> Maybe Bool
created :: Prelude.Maybe Prelude.Bool,
    -- | Deletion status of an OpenSearch Service domain. True if domain deletion
    -- is complete. False if domain deletion is still in progress. Once
    -- deletion is complete, the status of the domain is no longer returned.
    DomainStatus -> Maybe Bool
deleted :: Prelude.Maybe Prelude.Bool,
    -- | Additional options for the domain endpoint, such as whether to require
    -- HTTPS for all traffic.
    DomainStatus -> Maybe DomainEndpointOptions
domainEndpointOptions :: Prelude.Maybe DomainEndpointOptions,
    -- | Container for EBS-based storage settings for the domain.
    DomainStatus -> Maybe EBSOptions
eBSOptions :: Prelude.Maybe EBSOptions,
    -- | Encryption at rest settings for the domain.
    DomainStatus -> Maybe EncryptionAtRestOptions
encryptionAtRestOptions :: Prelude.Maybe EncryptionAtRestOptions,
    -- | Domain-specific endpoint used to submit index, search, and data upload
    -- requests to the domain.
    DomainStatus -> Maybe Text
endpoint :: Prelude.Maybe Prelude.Text,
    -- | The key-value pair that exists if the OpenSearch Service domain uses VPC
    -- endpoints.. Example @key, value@:
    -- @\'vpc\',\'vpc-endpoint-h2dsd34efgyghrtguk5gt6j2foh4.us-east-1.es.amazonaws.com\'@.
    DomainStatus -> Maybe (HashMap Text Text)
endpoints :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Version of OpenSearch or Elasticsearch that the domain is running, in
    -- the format @Elasticsearch_X.Y@ or @OpenSearch_X.Y@.
    DomainStatus -> Maybe Text
engineVersion :: Prelude.Maybe Prelude.Text,
    -- | Log publishing options for the domain.
    DomainStatus -> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions :: Prelude.Maybe (Prelude.HashMap LogType LogPublishingOption),
    -- | Whether node-to-node encryption is enabled or disabled.
    DomainStatus -> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions :: Prelude.Maybe NodeToNodeEncryptionOptions,
    -- | The status of the domain configuration. True if OpenSearch Service is
    -- processing configuration changes. False if the configuration is active.
    DomainStatus -> Maybe Bool
processing :: Prelude.Maybe Prelude.Bool,
    -- | The current status of the domain\'s service software.
    DomainStatus -> Maybe ServiceSoftwareOptions
serviceSoftwareOptions :: Prelude.Maybe ServiceSoftwareOptions,
    -- | DEPRECATED. Container for parameters required to configure automated
    -- snapshots of domain indexes.
    DomainStatus -> Maybe SnapshotOptions
snapshotOptions :: Prelude.Maybe SnapshotOptions,
    -- | The status of a domain version upgrade to a new version of OpenSearch or
    -- Elasticsearch. True if OpenSearch Service is in the process of a version
    -- upgrade. False if the configuration is active.
    DomainStatus -> Maybe Bool
upgradeProcessing :: Prelude.Maybe Prelude.Bool,
    -- | The VPC configuration for the domain.
    DomainStatus -> Maybe VPCDerivedInfo
vPCOptions :: Prelude.Maybe VPCDerivedInfo,
    -- | Unique identifier for the domain.
    DomainStatus -> Text
domainId :: Prelude.Text,
    -- | Name of the domain. Domain names are unique across all domains owned by
    -- the same account within an Amazon Web Services Region.
    DomainStatus -> Text
domainName :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the domain. For more information, see
    -- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html IAM identifiers>
    -- in the /AWS Identity and Access Management User Guide/.
    DomainStatus -> Text
arn :: Prelude.Text,
    -- | Container for the cluster configuration of the domain.
    DomainStatus -> ClusterConfig
clusterConfig :: ClusterConfig
  }
  deriving (DomainStatus -> DomainStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DomainStatus -> DomainStatus -> Bool
$c/= :: DomainStatus -> DomainStatus -> Bool
== :: DomainStatus -> DomainStatus -> Bool
$c== :: DomainStatus -> DomainStatus -> Bool
Prelude.Eq, ReadPrec [DomainStatus]
ReadPrec DomainStatus
Int -> ReadS DomainStatus
ReadS [DomainStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DomainStatus]
$creadListPrec :: ReadPrec [DomainStatus]
readPrec :: ReadPrec DomainStatus
$creadPrec :: ReadPrec DomainStatus
readList :: ReadS [DomainStatus]
$creadList :: ReadS [DomainStatus]
readsPrec :: Int -> ReadS DomainStatus
$creadsPrec :: Int -> ReadS DomainStatus
Prelude.Read, Int -> DomainStatus -> ShowS
[DomainStatus] -> ShowS
DomainStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DomainStatus] -> ShowS
$cshowList :: [DomainStatus] -> ShowS
show :: DomainStatus -> String
$cshow :: DomainStatus -> String
showsPrec :: Int -> DomainStatus -> ShowS
$cshowsPrec :: Int -> DomainStatus -> ShowS
Prelude.Show, forall x. Rep DomainStatus x -> DomainStatus
forall x. DomainStatus -> Rep DomainStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DomainStatus x -> DomainStatus
$cfrom :: forall x. DomainStatus -> Rep DomainStatus x
Prelude.Generic)

-- |
-- Create a value of 'DomainStatus' 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:
--
-- 'accessPolicies', 'domainStatus_accessPolicies' - Identity and Access Management (IAM) policy document specifying the
-- access policies for the domain.
--
-- 'advancedOptions', 'domainStatus_advancedOptions' - Key-value pairs that specify advanced configuration options.
--
-- 'advancedSecurityOptions', 'domainStatus_advancedSecurityOptions' - Settings for fine-grained access control.
--
-- 'autoTuneOptions', 'domainStatus_autoTuneOptions' - Auto-Tune settings for the domain.
--
-- 'changeProgressDetails', 'domainStatus_changeProgressDetails' - Information about a configuration change happening on the domain.
--
-- 'cognitoOptions', 'domainStatus_cognitoOptions' - Key-value pairs to configure Amazon Cognito authentication for
-- OpenSearch Dashboards.
--
-- 'created', 'domainStatus_created' - Creation status of an OpenSearch Service domain. True if domain creation
-- is complete. False if domain creation is still in progress.
--
-- 'deleted', 'domainStatus_deleted' - Deletion status of an OpenSearch Service domain. True if domain deletion
-- is complete. False if domain deletion is still in progress. Once
-- deletion is complete, the status of the domain is no longer returned.
--
-- 'domainEndpointOptions', 'domainStatus_domainEndpointOptions' - Additional options for the domain endpoint, such as whether to require
-- HTTPS for all traffic.
--
-- 'eBSOptions', 'domainStatus_eBSOptions' - Container for EBS-based storage settings for the domain.
--
-- 'encryptionAtRestOptions', 'domainStatus_encryptionAtRestOptions' - Encryption at rest settings for the domain.
--
-- 'endpoint', 'domainStatus_endpoint' - Domain-specific endpoint used to submit index, search, and data upload
-- requests to the domain.
--
-- 'endpoints', 'domainStatus_endpoints' - The key-value pair that exists if the OpenSearch Service domain uses VPC
-- endpoints.. Example @key, value@:
-- @\'vpc\',\'vpc-endpoint-h2dsd34efgyghrtguk5gt6j2foh4.us-east-1.es.amazonaws.com\'@.
--
-- 'engineVersion', 'domainStatus_engineVersion' - Version of OpenSearch or Elasticsearch that the domain is running, in
-- the format @Elasticsearch_X.Y@ or @OpenSearch_X.Y@.
--
-- 'logPublishingOptions', 'domainStatus_logPublishingOptions' - Log publishing options for the domain.
--
-- 'nodeToNodeEncryptionOptions', 'domainStatus_nodeToNodeEncryptionOptions' - Whether node-to-node encryption is enabled or disabled.
--
-- 'processing', 'domainStatus_processing' - The status of the domain configuration. True if OpenSearch Service is
-- processing configuration changes. False if the configuration is active.
--
-- 'serviceSoftwareOptions', 'domainStatus_serviceSoftwareOptions' - The current status of the domain\'s service software.
--
-- 'snapshotOptions', 'domainStatus_snapshotOptions' - DEPRECATED. Container for parameters required to configure automated
-- snapshots of domain indexes.
--
-- 'upgradeProcessing', 'domainStatus_upgradeProcessing' - The status of a domain version upgrade to a new version of OpenSearch or
-- Elasticsearch. True if OpenSearch Service is in the process of a version
-- upgrade. False if the configuration is active.
--
-- 'vPCOptions', 'domainStatus_vPCOptions' - The VPC configuration for the domain.
--
-- 'domainId', 'domainStatus_domainId' - Unique identifier for the domain.
--
-- 'domainName', 'domainStatus_domainName' - Name of the domain. Domain names are unique across all domains owned by
-- the same account within an Amazon Web Services Region.
--
-- 'arn', 'domainStatus_arn' - The Amazon Resource Name (ARN) of the domain. For more information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html IAM identifiers>
-- in the /AWS Identity and Access Management User Guide/.
--
-- 'clusterConfig', 'domainStatus_clusterConfig' - Container for the cluster configuration of the domain.
newDomainStatus ::
  -- | 'domainId'
  Prelude.Text ->
  -- | 'domainName'
  Prelude.Text ->
  -- | 'arn'
  Prelude.Text ->
  -- | 'clusterConfig'
  ClusterConfig ->
  DomainStatus
newDomainStatus :: Text -> Text -> Text -> ClusterConfig -> DomainStatus
newDomainStatus
  Text
pDomainId_
  Text
pDomainName_
  Text
pARN_
  ClusterConfig
pClusterConfig_ =
    DomainStatus'
      { $sel:accessPolicies:DomainStatus' :: Maybe Text
accessPolicies = forall a. Maybe a
Prelude.Nothing,
        $sel:advancedOptions:DomainStatus' :: Maybe (HashMap Text Text)
advancedOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:advancedSecurityOptions:DomainStatus' :: Maybe AdvancedSecurityOptions
advancedSecurityOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:autoTuneOptions:DomainStatus' :: Maybe AutoTuneOptionsOutput
autoTuneOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:changeProgressDetails:DomainStatus' :: Maybe ChangeProgressDetails
changeProgressDetails = forall a. Maybe a
Prelude.Nothing,
        $sel:cognitoOptions:DomainStatus' :: Maybe CognitoOptions
cognitoOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:created:DomainStatus' :: Maybe Bool
created = forall a. Maybe a
Prelude.Nothing,
        $sel:deleted:DomainStatus' :: Maybe Bool
deleted = forall a. Maybe a
Prelude.Nothing,
        $sel:domainEndpointOptions:DomainStatus' :: Maybe DomainEndpointOptions
domainEndpointOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:eBSOptions:DomainStatus' :: Maybe EBSOptions
eBSOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:encryptionAtRestOptions:DomainStatus' :: Maybe EncryptionAtRestOptions
encryptionAtRestOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:endpoint:DomainStatus' :: Maybe Text
endpoint = forall a. Maybe a
Prelude.Nothing,
        $sel:endpoints:DomainStatus' :: Maybe (HashMap Text Text)
endpoints = forall a. Maybe a
Prelude.Nothing,
        $sel:engineVersion:DomainStatus' :: Maybe Text
engineVersion = forall a. Maybe a
Prelude.Nothing,
        $sel:logPublishingOptions:DomainStatus' :: Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:nodeToNodeEncryptionOptions:DomainStatus' :: Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:processing:DomainStatus' :: Maybe Bool
processing = forall a. Maybe a
Prelude.Nothing,
        $sel:serviceSoftwareOptions:DomainStatus' :: Maybe ServiceSoftwareOptions
serviceSoftwareOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:snapshotOptions:DomainStatus' :: Maybe SnapshotOptions
snapshotOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:upgradeProcessing:DomainStatus' :: Maybe Bool
upgradeProcessing = forall a. Maybe a
Prelude.Nothing,
        $sel:vPCOptions:DomainStatus' :: Maybe VPCDerivedInfo
vPCOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:domainId:DomainStatus' :: Text
domainId = Text
pDomainId_,
        $sel:domainName:DomainStatus' :: Text
domainName = Text
pDomainName_,
        $sel:arn:DomainStatus' :: Text
arn = Text
pARN_,
        $sel:clusterConfig:DomainStatus' :: ClusterConfig
clusterConfig = ClusterConfig
pClusterConfig_
      }

-- | Identity and Access Management (IAM) policy document specifying the
-- access policies for the domain.
domainStatus_accessPolicies :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Text)
domainStatus_accessPolicies :: Lens' DomainStatus (Maybe Text)
domainStatus_accessPolicies = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Text
accessPolicies :: Maybe Text
$sel:accessPolicies:DomainStatus' :: DomainStatus -> Maybe Text
accessPolicies} -> Maybe Text
accessPolicies) (\s :: DomainStatus
s@DomainStatus' {} Maybe Text
a -> DomainStatus
s {$sel:accessPolicies:DomainStatus' :: Maybe Text
accessPolicies = Maybe Text
a} :: DomainStatus)

-- | Key-value pairs that specify advanced configuration options.
domainStatus_advancedOptions :: Lens.Lens' DomainStatus (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
domainStatus_advancedOptions :: Lens' DomainStatus (Maybe (HashMap Text Text))
domainStatus_advancedOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe (HashMap Text Text)
advancedOptions :: Maybe (HashMap Text Text)
$sel:advancedOptions:DomainStatus' :: DomainStatus -> Maybe (HashMap Text Text)
advancedOptions} -> Maybe (HashMap Text Text)
advancedOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe (HashMap Text Text)
a -> DomainStatus
s {$sel:advancedOptions:DomainStatus' :: Maybe (HashMap Text Text)
advancedOptions = Maybe (HashMap Text Text)
a} :: DomainStatus) 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

-- | Settings for fine-grained access control.
domainStatus_advancedSecurityOptions :: Lens.Lens' DomainStatus (Prelude.Maybe AdvancedSecurityOptions)
domainStatus_advancedSecurityOptions :: Lens' DomainStatus (Maybe AdvancedSecurityOptions)
domainStatus_advancedSecurityOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe AdvancedSecurityOptions
advancedSecurityOptions :: Maybe AdvancedSecurityOptions
$sel:advancedSecurityOptions:DomainStatus' :: DomainStatus -> Maybe AdvancedSecurityOptions
advancedSecurityOptions} -> Maybe AdvancedSecurityOptions
advancedSecurityOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe AdvancedSecurityOptions
a -> DomainStatus
s {$sel:advancedSecurityOptions:DomainStatus' :: Maybe AdvancedSecurityOptions
advancedSecurityOptions = Maybe AdvancedSecurityOptions
a} :: DomainStatus)

-- | Auto-Tune settings for the domain.
domainStatus_autoTuneOptions :: Lens.Lens' DomainStatus (Prelude.Maybe AutoTuneOptionsOutput)
domainStatus_autoTuneOptions :: Lens' DomainStatus (Maybe AutoTuneOptionsOutput)
domainStatus_autoTuneOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe AutoTuneOptionsOutput
autoTuneOptions :: Maybe AutoTuneOptionsOutput
$sel:autoTuneOptions:DomainStatus' :: DomainStatus -> Maybe AutoTuneOptionsOutput
autoTuneOptions} -> Maybe AutoTuneOptionsOutput
autoTuneOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe AutoTuneOptionsOutput
a -> DomainStatus
s {$sel:autoTuneOptions:DomainStatus' :: Maybe AutoTuneOptionsOutput
autoTuneOptions = Maybe AutoTuneOptionsOutput
a} :: DomainStatus)

-- | Information about a configuration change happening on the domain.
domainStatus_changeProgressDetails :: Lens.Lens' DomainStatus (Prelude.Maybe ChangeProgressDetails)
domainStatus_changeProgressDetails :: Lens' DomainStatus (Maybe ChangeProgressDetails)
domainStatus_changeProgressDetails = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe ChangeProgressDetails
changeProgressDetails :: Maybe ChangeProgressDetails
$sel:changeProgressDetails:DomainStatus' :: DomainStatus -> Maybe ChangeProgressDetails
changeProgressDetails} -> Maybe ChangeProgressDetails
changeProgressDetails) (\s :: DomainStatus
s@DomainStatus' {} Maybe ChangeProgressDetails
a -> DomainStatus
s {$sel:changeProgressDetails:DomainStatus' :: Maybe ChangeProgressDetails
changeProgressDetails = Maybe ChangeProgressDetails
a} :: DomainStatus)

-- | Key-value pairs to configure Amazon Cognito authentication for
-- OpenSearch Dashboards.
domainStatus_cognitoOptions :: Lens.Lens' DomainStatus (Prelude.Maybe CognitoOptions)
domainStatus_cognitoOptions :: Lens' DomainStatus (Maybe CognitoOptions)
domainStatus_cognitoOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe CognitoOptions
cognitoOptions :: Maybe CognitoOptions
$sel:cognitoOptions:DomainStatus' :: DomainStatus -> Maybe CognitoOptions
cognitoOptions} -> Maybe CognitoOptions
cognitoOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe CognitoOptions
a -> DomainStatus
s {$sel:cognitoOptions:DomainStatus' :: Maybe CognitoOptions
cognitoOptions = Maybe CognitoOptions
a} :: DomainStatus)

-- | Creation status of an OpenSearch Service domain. True if domain creation
-- is complete. False if domain creation is still in progress.
domainStatus_created :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Bool)
domainStatus_created :: Lens' DomainStatus (Maybe Bool)
domainStatus_created = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Bool
created :: Maybe Bool
$sel:created:DomainStatus' :: DomainStatus -> Maybe Bool
created} -> Maybe Bool
created) (\s :: DomainStatus
s@DomainStatus' {} Maybe Bool
a -> DomainStatus
s {$sel:created:DomainStatus' :: Maybe Bool
created = Maybe Bool
a} :: DomainStatus)

-- | Deletion status of an OpenSearch Service domain. True if domain deletion
-- is complete. False if domain deletion is still in progress. Once
-- deletion is complete, the status of the domain is no longer returned.
domainStatus_deleted :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Bool)
domainStatus_deleted :: Lens' DomainStatus (Maybe Bool)
domainStatus_deleted = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Bool
deleted :: Maybe Bool
$sel:deleted:DomainStatus' :: DomainStatus -> Maybe Bool
deleted} -> Maybe Bool
deleted) (\s :: DomainStatus
s@DomainStatus' {} Maybe Bool
a -> DomainStatus
s {$sel:deleted:DomainStatus' :: Maybe Bool
deleted = Maybe Bool
a} :: DomainStatus)

-- | Additional options for the domain endpoint, such as whether to require
-- HTTPS for all traffic.
domainStatus_domainEndpointOptions :: Lens.Lens' DomainStatus (Prelude.Maybe DomainEndpointOptions)
domainStatus_domainEndpointOptions :: Lens' DomainStatus (Maybe DomainEndpointOptions)
domainStatus_domainEndpointOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe DomainEndpointOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
$sel:domainEndpointOptions:DomainStatus' :: DomainStatus -> Maybe DomainEndpointOptions
domainEndpointOptions} -> Maybe DomainEndpointOptions
domainEndpointOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe DomainEndpointOptions
a -> DomainStatus
s {$sel:domainEndpointOptions:DomainStatus' :: Maybe DomainEndpointOptions
domainEndpointOptions = Maybe DomainEndpointOptions
a} :: DomainStatus)

-- | Container for EBS-based storage settings for the domain.
domainStatus_eBSOptions :: Lens.Lens' DomainStatus (Prelude.Maybe EBSOptions)
domainStatus_eBSOptions :: Lens' DomainStatus (Maybe EBSOptions)
domainStatus_eBSOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe EBSOptions
eBSOptions :: Maybe EBSOptions
$sel:eBSOptions:DomainStatus' :: DomainStatus -> Maybe EBSOptions
eBSOptions} -> Maybe EBSOptions
eBSOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe EBSOptions
a -> DomainStatus
s {$sel:eBSOptions:DomainStatus' :: Maybe EBSOptions
eBSOptions = Maybe EBSOptions
a} :: DomainStatus)

-- | Encryption at rest settings for the domain.
domainStatus_encryptionAtRestOptions :: Lens.Lens' DomainStatus (Prelude.Maybe EncryptionAtRestOptions)
domainStatus_encryptionAtRestOptions :: Lens' DomainStatus (Maybe EncryptionAtRestOptions)
domainStatus_encryptionAtRestOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe EncryptionAtRestOptions
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
$sel:encryptionAtRestOptions:DomainStatus' :: DomainStatus -> Maybe EncryptionAtRestOptions
encryptionAtRestOptions} -> Maybe EncryptionAtRestOptions
encryptionAtRestOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe EncryptionAtRestOptions
a -> DomainStatus
s {$sel:encryptionAtRestOptions:DomainStatus' :: Maybe EncryptionAtRestOptions
encryptionAtRestOptions = Maybe EncryptionAtRestOptions
a} :: DomainStatus)

-- | Domain-specific endpoint used to submit index, search, and data upload
-- requests to the domain.
domainStatus_endpoint :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Text)
domainStatus_endpoint :: Lens' DomainStatus (Maybe Text)
domainStatus_endpoint = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Text
endpoint :: Maybe Text
$sel:endpoint:DomainStatus' :: DomainStatus -> Maybe Text
endpoint} -> Maybe Text
endpoint) (\s :: DomainStatus
s@DomainStatus' {} Maybe Text
a -> DomainStatus
s {$sel:endpoint:DomainStatus' :: Maybe Text
endpoint = Maybe Text
a} :: DomainStatus)

-- | The key-value pair that exists if the OpenSearch Service domain uses VPC
-- endpoints.. Example @key, value@:
-- @\'vpc\',\'vpc-endpoint-h2dsd34efgyghrtguk5gt6j2foh4.us-east-1.es.amazonaws.com\'@.
domainStatus_endpoints :: Lens.Lens' DomainStatus (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
domainStatus_endpoints :: Lens' DomainStatus (Maybe (HashMap Text Text))
domainStatus_endpoints = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe (HashMap Text Text)
endpoints :: Maybe (HashMap Text Text)
$sel:endpoints:DomainStatus' :: DomainStatus -> Maybe (HashMap Text Text)
endpoints} -> Maybe (HashMap Text Text)
endpoints) (\s :: DomainStatus
s@DomainStatus' {} Maybe (HashMap Text Text)
a -> DomainStatus
s {$sel:endpoints:DomainStatus' :: Maybe (HashMap Text Text)
endpoints = Maybe (HashMap Text Text)
a} :: DomainStatus) 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

-- | Version of OpenSearch or Elasticsearch that the domain is running, in
-- the format @Elasticsearch_X.Y@ or @OpenSearch_X.Y@.
domainStatus_engineVersion :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Text)
domainStatus_engineVersion :: Lens' DomainStatus (Maybe Text)
domainStatus_engineVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Text
engineVersion :: Maybe Text
$sel:engineVersion:DomainStatus' :: DomainStatus -> Maybe Text
engineVersion} -> Maybe Text
engineVersion) (\s :: DomainStatus
s@DomainStatus' {} Maybe Text
a -> DomainStatus
s {$sel:engineVersion:DomainStatus' :: Maybe Text
engineVersion = Maybe Text
a} :: DomainStatus)

-- | Log publishing options for the domain.
domainStatus_logPublishingOptions :: Lens.Lens' DomainStatus (Prelude.Maybe (Prelude.HashMap LogType LogPublishingOption))
domainStatus_logPublishingOptions :: Lens' DomainStatus (Maybe (HashMap LogType LogPublishingOption))
domainStatus_logPublishingOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
$sel:logPublishingOptions:DomainStatus' :: DomainStatus -> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions} -> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe (HashMap LogType LogPublishingOption)
a -> DomainStatus
s {$sel:logPublishingOptions:DomainStatus' :: Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions = Maybe (HashMap LogType LogPublishingOption)
a} :: DomainStatus) 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

-- | Whether node-to-node encryption is enabled or disabled.
domainStatus_nodeToNodeEncryptionOptions :: Lens.Lens' DomainStatus (Prelude.Maybe NodeToNodeEncryptionOptions)
domainStatus_nodeToNodeEncryptionOptions :: Lens' DomainStatus (Maybe NodeToNodeEncryptionOptions)
domainStatus_nodeToNodeEncryptionOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
$sel:nodeToNodeEncryptionOptions:DomainStatus' :: DomainStatus -> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions} -> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe NodeToNodeEncryptionOptions
a -> DomainStatus
s {$sel:nodeToNodeEncryptionOptions:DomainStatus' :: Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions = Maybe NodeToNodeEncryptionOptions
a} :: DomainStatus)

-- | The status of the domain configuration. True if OpenSearch Service is
-- processing configuration changes. False if the configuration is active.
domainStatus_processing :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Bool)
domainStatus_processing :: Lens' DomainStatus (Maybe Bool)
domainStatus_processing = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Bool
processing :: Maybe Bool
$sel:processing:DomainStatus' :: DomainStatus -> Maybe Bool
processing} -> Maybe Bool
processing) (\s :: DomainStatus
s@DomainStatus' {} Maybe Bool
a -> DomainStatus
s {$sel:processing:DomainStatus' :: Maybe Bool
processing = Maybe Bool
a} :: DomainStatus)

-- | The current status of the domain\'s service software.
domainStatus_serviceSoftwareOptions :: Lens.Lens' DomainStatus (Prelude.Maybe ServiceSoftwareOptions)
domainStatus_serviceSoftwareOptions :: Lens' DomainStatus (Maybe ServiceSoftwareOptions)
domainStatus_serviceSoftwareOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe ServiceSoftwareOptions
serviceSoftwareOptions :: Maybe ServiceSoftwareOptions
$sel:serviceSoftwareOptions:DomainStatus' :: DomainStatus -> Maybe ServiceSoftwareOptions
serviceSoftwareOptions} -> Maybe ServiceSoftwareOptions
serviceSoftwareOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe ServiceSoftwareOptions
a -> DomainStatus
s {$sel:serviceSoftwareOptions:DomainStatus' :: Maybe ServiceSoftwareOptions
serviceSoftwareOptions = Maybe ServiceSoftwareOptions
a} :: DomainStatus)

-- | DEPRECATED. Container for parameters required to configure automated
-- snapshots of domain indexes.
domainStatus_snapshotOptions :: Lens.Lens' DomainStatus (Prelude.Maybe SnapshotOptions)
domainStatus_snapshotOptions :: Lens' DomainStatus (Maybe SnapshotOptions)
domainStatus_snapshotOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe SnapshotOptions
snapshotOptions :: Maybe SnapshotOptions
$sel:snapshotOptions:DomainStatus' :: DomainStatus -> Maybe SnapshotOptions
snapshotOptions} -> Maybe SnapshotOptions
snapshotOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe SnapshotOptions
a -> DomainStatus
s {$sel:snapshotOptions:DomainStatus' :: Maybe SnapshotOptions
snapshotOptions = Maybe SnapshotOptions
a} :: DomainStatus)

-- | The status of a domain version upgrade to a new version of OpenSearch or
-- Elasticsearch. True if OpenSearch Service is in the process of a version
-- upgrade. False if the configuration is active.
domainStatus_upgradeProcessing :: Lens.Lens' DomainStatus (Prelude.Maybe Prelude.Bool)
domainStatus_upgradeProcessing :: Lens' DomainStatus (Maybe Bool)
domainStatus_upgradeProcessing = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe Bool
upgradeProcessing :: Maybe Bool
$sel:upgradeProcessing:DomainStatus' :: DomainStatus -> Maybe Bool
upgradeProcessing} -> Maybe Bool
upgradeProcessing) (\s :: DomainStatus
s@DomainStatus' {} Maybe Bool
a -> DomainStatus
s {$sel:upgradeProcessing:DomainStatus' :: Maybe Bool
upgradeProcessing = Maybe Bool
a} :: DomainStatus)

-- | The VPC configuration for the domain.
domainStatus_vPCOptions :: Lens.Lens' DomainStatus (Prelude.Maybe VPCDerivedInfo)
domainStatus_vPCOptions :: Lens' DomainStatus (Maybe VPCDerivedInfo)
domainStatus_vPCOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Maybe VPCDerivedInfo
vPCOptions :: Maybe VPCDerivedInfo
$sel:vPCOptions:DomainStatus' :: DomainStatus -> Maybe VPCDerivedInfo
vPCOptions} -> Maybe VPCDerivedInfo
vPCOptions) (\s :: DomainStatus
s@DomainStatus' {} Maybe VPCDerivedInfo
a -> DomainStatus
s {$sel:vPCOptions:DomainStatus' :: Maybe VPCDerivedInfo
vPCOptions = Maybe VPCDerivedInfo
a} :: DomainStatus)

-- | Unique identifier for the domain.
domainStatus_domainId :: Lens.Lens' DomainStatus Prelude.Text
domainStatus_domainId :: Lens' DomainStatus Text
domainStatus_domainId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Text
domainId :: Text
$sel:domainId:DomainStatus' :: DomainStatus -> Text
domainId} -> Text
domainId) (\s :: DomainStatus
s@DomainStatus' {} Text
a -> DomainStatus
s {$sel:domainId:DomainStatus' :: Text
domainId = Text
a} :: DomainStatus)

-- | Name of the domain. Domain names are unique across all domains owned by
-- the same account within an Amazon Web Services Region.
domainStatus_domainName :: Lens.Lens' DomainStatus Prelude.Text
domainStatus_domainName :: Lens' DomainStatus Text
domainStatus_domainName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Text
domainName :: Text
$sel:domainName:DomainStatus' :: DomainStatus -> Text
domainName} -> Text
domainName) (\s :: DomainStatus
s@DomainStatus' {} Text
a -> DomainStatus
s {$sel:domainName:DomainStatus' :: Text
domainName = Text
a} :: DomainStatus)

-- | The Amazon Resource Name (ARN) of the domain. For more information, see
-- <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html IAM identifiers>
-- in the /AWS Identity and Access Management User Guide/.
domainStatus_arn :: Lens.Lens' DomainStatus Prelude.Text
domainStatus_arn :: Lens' DomainStatus Text
domainStatus_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {Text
arn :: Text
$sel:arn:DomainStatus' :: DomainStatus -> Text
arn} -> Text
arn) (\s :: DomainStatus
s@DomainStatus' {} Text
a -> DomainStatus
s {$sel:arn:DomainStatus' :: Text
arn = Text
a} :: DomainStatus)

-- | Container for the cluster configuration of the domain.
domainStatus_clusterConfig :: Lens.Lens' DomainStatus ClusterConfig
domainStatus_clusterConfig :: Lens' DomainStatus ClusterConfig
domainStatus_clusterConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DomainStatus' {ClusterConfig
clusterConfig :: ClusterConfig
$sel:clusterConfig:DomainStatus' :: DomainStatus -> ClusterConfig
clusterConfig} -> ClusterConfig
clusterConfig) (\s :: DomainStatus
s@DomainStatus' {} ClusterConfig
a -> DomainStatus
s {$sel:clusterConfig:DomainStatus' :: ClusterConfig
clusterConfig = ClusterConfig
a} :: DomainStatus)

instance Data.FromJSON DomainStatus where
  parseJSON :: Value -> Parser DomainStatus
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"DomainStatus"
      ( \Object
x ->
          Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe AdvancedSecurityOptions
-> Maybe AutoTuneOptionsOutput
-> Maybe ChangeProgressDetails
-> Maybe CognitoOptions
-> Maybe Bool
-> Maybe Bool
-> Maybe DomainEndpointOptions
-> Maybe EBSOptions
-> Maybe EncryptionAtRestOptions
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Maybe (HashMap LogType LogPublishingOption)
-> Maybe NodeToNodeEncryptionOptions
-> Maybe Bool
-> Maybe ServiceSoftwareOptions
-> Maybe SnapshotOptions
-> Maybe Bool
-> Maybe VPCDerivedInfo
-> Text
-> Text
-> Text
-> ClusterConfig
-> DomainStatus
DomainStatus'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"AccessPolicies")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"AdvancedOptions"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"AdvancedSecurityOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"AutoTuneOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ChangeProgressDetails")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CognitoOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Created")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Deleted")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DomainEndpointOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EBSOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EncryptionAtRestOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Endpoint")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Endpoints" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"EngineVersion")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LogPublishingOptions"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"NodeToNodeEncryptionOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Processing")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ServiceSoftwareOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"SnapshotOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"UpgradeProcessing")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"VPCOptions")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"DomainId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"DomainName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"ARN")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"ClusterConfig")
      )

instance Prelude.Hashable DomainStatus where
  hashWithSalt :: Int -> DomainStatus -> Int
hashWithSalt Int
_salt DomainStatus' {Maybe Bool
Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap LogType LogPublishingOption)
Maybe AutoTuneOptionsOutput
Maybe ChangeProgressDetails
Maybe CognitoOptions
Maybe EncryptionAtRestOptions
Maybe NodeToNodeEncryptionOptions
Maybe AdvancedSecurityOptions
Maybe ServiceSoftwareOptions
Maybe SnapshotOptions
Maybe DomainEndpointOptions
Maybe VPCDerivedInfo
Maybe EBSOptions
Text
ClusterConfig
clusterConfig :: ClusterConfig
arn :: Text
domainName :: Text
domainId :: Text
vPCOptions :: Maybe VPCDerivedInfo
upgradeProcessing :: Maybe Bool
snapshotOptions :: Maybe SnapshotOptions
serviceSoftwareOptions :: Maybe ServiceSoftwareOptions
processing :: Maybe Bool
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
engineVersion :: Maybe Text
endpoints :: Maybe (HashMap Text Text)
endpoint :: Maybe Text
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
eBSOptions :: Maybe EBSOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
deleted :: Maybe Bool
created :: Maybe Bool
cognitoOptions :: Maybe CognitoOptions
changeProgressDetails :: Maybe ChangeProgressDetails
autoTuneOptions :: Maybe AutoTuneOptionsOutput
advancedSecurityOptions :: Maybe AdvancedSecurityOptions
advancedOptions :: Maybe (HashMap Text Text)
accessPolicies :: Maybe Text
$sel:clusterConfig:DomainStatus' :: DomainStatus -> ClusterConfig
$sel:arn:DomainStatus' :: DomainStatus -> Text
$sel:domainName:DomainStatus' :: DomainStatus -> Text
$sel:domainId:DomainStatus' :: DomainStatus -> Text
$sel:vPCOptions:DomainStatus' :: DomainStatus -> Maybe VPCDerivedInfo
$sel:upgradeProcessing:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:snapshotOptions:DomainStatus' :: DomainStatus -> Maybe SnapshotOptions
$sel:serviceSoftwareOptions:DomainStatus' :: DomainStatus -> Maybe ServiceSoftwareOptions
$sel:processing:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:nodeToNodeEncryptionOptions:DomainStatus' :: DomainStatus -> Maybe NodeToNodeEncryptionOptions
$sel:logPublishingOptions:DomainStatus' :: DomainStatus -> Maybe (HashMap LogType LogPublishingOption)
$sel:engineVersion:DomainStatus' :: DomainStatus -> Maybe Text
$sel:endpoints:DomainStatus' :: DomainStatus -> Maybe (HashMap Text Text)
$sel:endpoint:DomainStatus' :: DomainStatus -> Maybe Text
$sel:encryptionAtRestOptions:DomainStatus' :: DomainStatus -> Maybe EncryptionAtRestOptions
$sel:eBSOptions:DomainStatus' :: DomainStatus -> Maybe EBSOptions
$sel:domainEndpointOptions:DomainStatus' :: DomainStatus -> Maybe DomainEndpointOptions
$sel:deleted:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:created:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:cognitoOptions:DomainStatus' :: DomainStatus -> Maybe CognitoOptions
$sel:changeProgressDetails:DomainStatus' :: DomainStatus -> Maybe ChangeProgressDetails
$sel:autoTuneOptions:DomainStatus' :: DomainStatus -> Maybe AutoTuneOptionsOutput
$sel:advancedSecurityOptions:DomainStatus' :: DomainStatus -> Maybe AdvancedSecurityOptions
$sel:advancedOptions:DomainStatus' :: DomainStatus -> Maybe (HashMap Text Text)
$sel:accessPolicies:DomainStatus' :: DomainStatus -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
accessPolicies
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
advancedOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AdvancedSecurityOptions
advancedSecurityOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AutoTuneOptionsOutput
autoTuneOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ChangeProgressDetails
changeProgressDetails
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CognitoOptions
cognitoOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
created
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
deleted
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DomainEndpointOptions
domainEndpointOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EBSOptions
eBSOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EncryptionAtRestOptions
encryptionAtRestOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
endpoint
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
endpoints
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
engineVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
processing
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ServiceSoftwareOptions
serviceSoftwareOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SnapshotOptions
snapshotOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
upgradeProcessing
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VPCDerivedInfo
vPCOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
arn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ClusterConfig
clusterConfig

instance Prelude.NFData DomainStatus where
  rnf :: DomainStatus -> ()
rnf DomainStatus' {Maybe Bool
Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap LogType LogPublishingOption)
Maybe AutoTuneOptionsOutput
Maybe ChangeProgressDetails
Maybe CognitoOptions
Maybe EncryptionAtRestOptions
Maybe NodeToNodeEncryptionOptions
Maybe AdvancedSecurityOptions
Maybe ServiceSoftwareOptions
Maybe SnapshotOptions
Maybe DomainEndpointOptions
Maybe VPCDerivedInfo
Maybe EBSOptions
Text
ClusterConfig
clusterConfig :: ClusterConfig
arn :: Text
domainName :: Text
domainId :: Text
vPCOptions :: Maybe VPCDerivedInfo
upgradeProcessing :: Maybe Bool
snapshotOptions :: Maybe SnapshotOptions
serviceSoftwareOptions :: Maybe ServiceSoftwareOptions
processing :: Maybe Bool
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
engineVersion :: Maybe Text
endpoints :: Maybe (HashMap Text Text)
endpoint :: Maybe Text
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
eBSOptions :: Maybe EBSOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
deleted :: Maybe Bool
created :: Maybe Bool
cognitoOptions :: Maybe CognitoOptions
changeProgressDetails :: Maybe ChangeProgressDetails
autoTuneOptions :: Maybe AutoTuneOptionsOutput
advancedSecurityOptions :: Maybe AdvancedSecurityOptions
advancedOptions :: Maybe (HashMap Text Text)
accessPolicies :: Maybe Text
$sel:clusterConfig:DomainStatus' :: DomainStatus -> ClusterConfig
$sel:arn:DomainStatus' :: DomainStatus -> Text
$sel:domainName:DomainStatus' :: DomainStatus -> Text
$sel:domainId:DomainStatus' :: DomainStatus -> Text
$sel:vPCOptions:DomainStatus' :: DomainStatus -> Maybe VPCDerivedInfo
$sel:upgradeProcessing:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:snapshotOptions:DomainStatus' :: DomainStatus -> Maybe SnapshotOptions
$sel:serviceSoftwareOptions:DomainStatus' :: DomainStatus -> Maybe ServiceSoftwareOptions
$sel:processing:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:nodeToNodeEncryptionOptions:DomainStatus' :: DomainStatus -> Maybe NodeToNodeEncryptionOptions
$sel:logPublishingOptions:DomainStatus' :: DomainStatus -> Maybe (HashMap LogType LogPublishingOption)
$sel:engineVersion:DomainStatus' :: DomainStatus -> Maybe Text
$sel:endpoints:DomainStatus' :: DomainStatus -> Maybe (HashMap Text Text)
$sel:endpoint:DomainStatus' :: DomainStatus -> Maybe Text
$sel:encryptionAtRestOptions:DomainStatus' :: DomainStatus -> Maybe EncryptionAtRestOptions
$sel:eBSOptions:DomainStatus' :: DomainStatus -> Maybe EBSOptions
$sel:domainEndpointOptions:DomainStatus' :: DomainStatus -> Maybe DomainEndpointOptions
$sel:deleted:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:created:DomainStatus' :: DomainStatus -> Maybe Bool
$sel:cognitoOptions:DomainStatus' :: DomainStatus -> Maybe CognitoOptions
$sel:changeProgressDetails:DomainStatus' :: DomainStatus -> Maybe ChangeProgressDetails
$sel:autoTuneOptions:DomainStatus' :: DomainStatus -> Maybe AutoTuneOptionsOutput
$sel:advancedSecurityOptions:DomainStatus' :: DomainStatus -> Maybe AdvancedSecurityOptions
$sel:advancedOptions:DomainStatus' :: DomainStatus -> Maybe (HashMap Text Text)
$sel:accessPolicies:DomainStatus' :: DomainStatus -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
accessPolicies
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
advancedOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AdvancedSecurityOptions
advancedSecurityOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AutoTuneOptionsOutput
autoTuneOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ChangeProgressDetails
changeProgressDetails
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CognitoOptions
cognitoOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
created
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
deleted
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DomainEndpointOptions
domainEndpointOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EBSOptions
eBSOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EncryptionAtRestOptions
encryptionAtRestOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
endpoint
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
endpoints
      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 (HashMap LogType LogPublishingOption)
logPublishingOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
processing
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ServiceSoftwareOptions
serviceSoftwareOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SnapshotOptions
snapshotOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
upgradeProcessing
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VPCDerivedInfo
vPCOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        ClusterConfig
clusterConfig