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

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

-- |
-- Module      : Amazonka.ElasticSearch.CreateElasticsearchDomain
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a new Elasticsearch domain. For more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomains Creating Elasticsearch Domains>
-- in the /Amazon Elasticsearch Service Developer Guide/.
module Amazonka.ElasticSearch.CreateElasticsearchDomain
  ( -- * Creating a Request
    CreateElasticsearchDomain (..),
    newCreateElasticsearchDomain,

    -- * Request Lenses
    createElasticsearchDomain_accessPolicies,
    createElasticsearchDomain_advancedOptions,
    createElasticsearchDomain_advancedSecurityOptions,
    createElasticsearchDomain_autoTuneOptions,
    createElasticsearchDomain_cognitoOptions,
    createElasticsearchDomain_domainEndpointOptions,
    createElasticsearchDomain_eBSOptions,
    createElasticsearchDomain_elasticsearchClusterConfig,
    createElasticsearchDomain_elasticsearchVersion,
    createElasticsearchDomain_encryptionAtRestOptions,
    createElasticsearchDomain_logPublishingOptions,
    createElasticsearchDomain_nodeToNodeEncryptionOptions,
    createElasticsearchDomain_snapshotOptions,
    createElasticsearchDomain_tagList,
    createElasticsearchDomain_vPCOptions,
    createElasticsearchDomain_domainName,

    -- * Destructuring the Response
    CreateElasticsearchDomainResponse (..),
    newCreateElasticsearchDomainResponse,

    -- * Response Lenses
    createElasticsearchDomainResponse_domainStatus,
    createElasticsearchDomainResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.ElasticSearch.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateElasticsearchDomain' smart constructor.
data CreateElasticsearchDomain = CreateElasticsearchDomain'
  { -- | IAM access policy as a JSON-formatted string.
    CreateElasticsearchDomain -> Maybe Text
accessPolicies :: Prelude.Maybe Prelude.Text,
    -- | Option to allow references to indices in an HTTP request body. Must be
    -- @false@ when configuring access to individual sub-resources. By default,
    -- the value is @true@. See
    -- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomain-configure-advanced-options Configuration Advanced Options>
    -- for more information.
    CreateElasticsearchDomain -> Maybe (HashMap Text Text)
advancedOptions :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | Specifies advanced security options.
    CreateElasticsearchDomain -> Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions :: Prelude.Maybe AdvancedSecurityOptionsInput,
    -- | Specifies Auto-Tune options.
    CreateElasticsearchDomain -> Maybe AutoTuneOptionsInput
autoTuneOptions :: Prelude.Maybe AutoTuneOptionsInput,
    -- | Options to specify the Cognito user and identity pools for Kibana
    -- authentication. For more information, see
    -- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-cognito-auth.html Amazon Cognito Authentication for Kibana>.
    CreateElasticsearchDomain -> Maybe CognitoOptions
cognitoOptions :: Prelude.Maybe CognitoOptions,
    -- | Options to specify configuration that will be applied to the domain
    -- endpoint.
    CreateElasticsearchDomain -> Maybe DomainEndpointOptions
domainEndpointOptions :: Prelude.Maybe DomainEndpointOptions,
    -- | Options to enable, disable and specify the type and size of EBS storage
    -- volumes.
    CreateElasticsearchDomain -> Maybe EBSOptions
eBSOptions :: Prelude.Maybe EBSOptions,
    -- | Configuration options for an Elasticsearch domain. Specifies the
    -- instance type and number of instances in the domain cluster.
    CreateElasticsearchDomain -> Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig :: Prelude.Maybe ElasticsearchClusterConfig,
    -- | String of format X.Y to specify version for the Elasticsearch domain eg.
    -- \"1.5\" or \"2.3\". For more information, see
    -- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomains Creating Elasticsearch Domains>
    -- in the /Amazon Elasticsearch Service Developer Guide/.
    CreateElasticsearchDomain -> Maybe Text
elasticsearchVersion :: Prelude.Maybe Prelude.Text,
    -- | Specifies the Encryption At Rest Options.
    CreateElasticsearchDomain -> Maybe EncryptionAtRestOptions
encryptionAtRestOptions :: Prelude.Maybe EncryptionAtRestOptions,
    -- | Map of @LogType@ and @LogPublishingOption@, each containing options to
    -- publish a given type of Elasticsearch log.
    CreateElasticsearchDomain
-> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions :: Prelude.Maybe (Prelude.HashMap LogType LogPublishingOption),
    -- | Specifies the NodeToNodeEncryptionOptions.
    CreateElasticsearchDomain -> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions :: Prelude.Maybe NodeToNodeEncryptionOptions,
    -- | Option to set time, in UTC format, of the daily automated snapshot.
    -- Default value is 0 hours.
    CreateElasticsearchDomain -> Maybe SnapshotOptions
snapshotOptions :: Prelude.Maybe SnapshotOptions,
    -- | A list of @Tag@ added during domain creation.
    CreateElasticsearchDomain -> Maybe [Tag]
tagList :: Prelude.Maybe [Tag],
    -- | Options to specify the subnets and security groups for VPC endpoint. For
    -- more information, see
    -- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html#es-creating-vpc Creating a VPC>
    -- in /VPC Endpoints for Amazon Elasticsearch Service Domains/
    CreateElasticsearchDomain -> Maybe VPCOptions
vPCOptions :: Prelude.Maybe VPCOptions,
    -- | The name of the Elasticsearch domain that you are creating. Domain names
    -- are unique across the domains owned by an account within an AWS region.
    -- Domain names must start with a lowercase letter and can contain the
    -- following characters: a-z (lowercase), 0-9, and - (hyphen).
    CreateElasticsearchDomain -> Text
domainName :: Prelude.Text
  }
  deriving (CreateElasticsearchDomain -> CreateElasticsearchDomain -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateElasticsearchDomain -> CreateElasticsearchDomain -> Bool
$c/= :: CreateElasticsearchDomain -> CreateElasticsearchDomain -> Bool
== :: CreateElasticsearchDomain -> CreateElasticsearchDomain -> Bool
$c== :: CreateElasticsearchDomain -> CreateElasticsearchDomain -> Bool
Prelude.Eq, Int -> CreateElasticsearchDomain -> ShowS
[CreateElasticsearchDomain] -> ShowS
CreateElasticsearchDomain -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateElasticsearchDomain] -> ShowS
$cshowList :: [CreateElasticsearchDomain] -> ShowS
show :: CreateElasticsearchDomain -> String
$cshow :: CreateElasticsearchDomain -> String
showsPrec :: Int -> CreateElasticsearchDomain -> ShowS
$cshowsPrec :: Int -> CreateElasticsearchDomain -> ShowS
Prelude.Show, forall x.
Rep CreateElasticsearchDomain x -> CreateElasticsearchDomain
forall x.
CreateElasticsearchDomain -> Rep CreateElasticsearchDomain x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateElasticsearchDomain x -> CreateElasticsearchDomain
$cfrom :: forall x.
CreateElasticsearchDomain -> Rep CreateElasticsearchDomain x
Prelude.Generic)

-- |
-- Create a value of 'CreateElasticsearchDomain' 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', 'createElasticsearchDomain_accessPolicies' - IAM access policy as a JSON-formatted string.
--
-- 'advancedOptions', 'createElasticsearchDomain_advancedOptions' - Option to allow references to indices in an HTTP request body. Must be
-- @false@ when configuring access to individual sub-resources. By default,
-- the value is @true@. See
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomain-configure-advanced-options Configuration Advanced Options>
-- for more information.
--
-- 'advancedSecurityOptions', 'createElasticsearchDomain_advancedSecurityOptions' - Specifies advanced security options.
--
-- 'autoTuneOptions', 'createElasticsearchDomain_autoTuneOptions' - Specifies Auto-Tune options.
--
-- 'cognitoOptions', 'createElasticsearchDomain_cognitoOptions' - Options to specify the Cognito user and identity pools for Kibana
-- authentication. For more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-cognito-auth.html Amazon Cognito Authentication for Kibana>.
--
-- 'domainEndpointOptions', 'createElasticsearchDomain_domainEndpointOptions' - Options to specify configuration that will be applied to the domain
-- endpoint.
--
-- 'eBSOptions', 'createElasticsearchDomain_eBSOptions' - Options to enable, disable and specify the type and size of EBS storage
-- volumes.
--
-- 'elasticsearchClusterConfig', 'createElasticsearchDomain_elasticsearchClusterConfig' - Configuration options for an Elasticsearch domain. Specifies the
-- instance type and number of instances in the domain cluster.
--
-- 'elasticsearchVersion', 'createElasticsearchDomain_elasticsearchVersion' - String of format X.Y to specify version for the Elasticsearch domain eg.
-- \"1.5\" or \"2.3\". For more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomains Creating Elasticsearch Domains>
-- in the /Amazon Elasticsearch Service Developer Guide/.
--
-- 'encryptionAtRestOptions', 'createElasticsearchDomain_encryptionAtRestOptions' - Specifies the Encryption At Rest Options.
--
-- 'logPublishingOptions', 'createElasticsearchDomain_logPublishingOptions' - Map of @LogType@ and @LogPublishingOption@, each containing options to
-- publish a given type of Elasticsearch log.
--
-- 'nodeToNodeEncryptionOptions', 'createElasticsearchDomain_nodeToNodeEncryptionOptions' - Specifies the NodeToNodeEncryptionOptions.
--
-- 'snapshotOptions', 'createElasticsearchDomain_snapshotOptions' - Option to set time, in UTC format, of the daily automated snapshot.
-- Default value is 0 hours.
--
-- 'tagList', 'createElasticsearchDomain_tagList' - A list of @Tag@ added during domain creation.
--
-- 'vPCOptions', 'createElasticsearchDomain_vPCOptions' - Options to specify the subnets and security groups for VPC endpoint. For
-- more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html#es-creating-vpc Creating a VPC>
-- in /VPC Endpoints for Amazon Elasticsearch Service Domains/
--
-- 'domainName', 'createElasticsearchDomain_domainName' - The name of the Elasticsearch domain that you are creating. Domain names
-- are unique across the domains owned by an account within an AWS region.
-- Domain names must start with a lowercase letter and can contain the
-- following characters: a-z (lowercase), 0-9, and - (hyphen).
newCreateElasticsearchDomain ::
  -- | 'domainName'
  Prelude.Text ->
  CreateElasticsearchDomain
newCreateElasticsearchDomain :: Text -> CreateElasticsearchDomain
newCreateElasticsearchDomain Text
pDomainName_ =
  CreateElasticsearchDomain'
    { $sel:accessPolicies:CreateElasticsearchDomain' :: Maybe Text
accessPolicies =
        forall a. Maybe a
Prelude.Nothing,
      $sel:advancedOptions:CreateElasticsearchDomain' :: Maybe (HashMap Text Text)
advancedOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:advancedSecurityOptions:CreateElasticsearchDomain' :: Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:autoTuneOptions:CreateElasticsearchDomain' :: Maybe AutoTuneOptionsInput
autoTuneOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:cognitoOptions:CreateElasticsearchDomain' :: Maybe CognitoOptions
cognitoOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:domainEndpointOptions:CreateElasticsearchDomain' :: Maybe DomainEndpointOptions
domainEndpointOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:eBSOptions:CreateElasticsearchDomain' :: Maybe EBSOptions
eBSOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:elasticsearchClusterConfig:CreateElasticsearchDomain' :: Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:elasticsearchVersion:CreateElasticsearchDomain' :: Maybe Text
elasticsearchVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:encryptionAtRestOptions:CreateElasticsearchDomain' :: Maybe EncryptionAtRestOptions
encryptionAtRestOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:logPublishingOptions:CreateElasticsearchDomain' :: Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:nodeToNodeEncryptionOptions:CreateElasticsearchDomain' :: Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:snapshotOptions:CreateElasticsearchDomain' :: Maybe SnapshotOptions
snapshotOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:tagList:CreateElasticsearchDomain' :: Maybe [Tag]
tagList = forall a. Maybe a
Prelude.Nothing,
      $sel:vPCOptions:CreateElasticsearchDomain' :: Maybe VPCOptions
vPCOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:domainName:CreateElasticsearchDomain' :: Text
domainName = Text
pDomainName_
    }

-- | IAM access policy as a JSON-formatted string.
createElasticsearchDomain_accessPolicies :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe Prelude.Text)
createElasticsearchDomain_accessPolicies :: Lens' CreateElasticsearchDomain (Maybe Text)
createElasticsearchDomain_accessPolicies = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe Text
accessPolicies :: Maybe Text
$sel:accessPolicies:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe Text
accessPolicies} -> Maybe Text
accessPolicies) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe Text
a -> CreateElasticsearchDomain
s {$sel:accessPolicies:CreateElasticsearchDomain' :: Maybe Text
accessPolicies = Maybe Text
a} :: CreateElasticsearchDomain)

-- | Option to allow references to indices in an HTTP request body. Must be
-- @false@ when configuring access to individual sub-resources. By default,
-- the value is @true@. See
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomain-configure-advanced-options Configuration Advanced Options>
-- for more information.
createElasticsearchDomain_advancedOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createElasticsearchDomain_advancedOptions :: Lens' CreateElasticsearchDomain (Maybe (HashMap Text Text))
createElasticsearchDomain_advancedOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe (HashMap Text Text)
advancedOptions :: Maybe (HashMap Text Text)
$sel:advancedOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe (HashMap Text Text)
advancedOptions} -> Maybe (HashMap Text Text)
advancedOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe (HashMap Text Text)
a -> CreateElasticsearchDomain
s {$sel:advancedOptions:CreateElasticsearchDomain' :: Maybe (HashMap Text Text)
advancedOptions = Maybe (HashMap Text Text)
a} :: CreateElasticsearchDomain) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies advanced security options.
createElasticsearchDomain_advancedSecurityOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe AdvancedSecurityOptionsInput)
createElasticsearchDomain_advancedSecurityOptions :: Lens'
  CreateElasticsearchDomain (Maybe AdvancedSecurityOptionsInput)
createElasticsearchDomain_advancedSecurityOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions :: Maybe AdvancedSecurityOptionsInput
$sel:advancedSecurityOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions} -> Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe AdvancedSecurityOptionsInput
a -> CreateElasticsearchDomain
s {$sel:advancedSecurityOptions:CreateElasticsearchDomain' :: Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions = Maybe AdvancedSecurityOptionsInput
a} :: CreateElasticsearchDomain)

-- | Specifies Auto-Tune options.
createElasticsearchDomain_autoTuneOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe AutoTuneOptionsInput)
createElasticsearchDomain_autoTuneOptions :: Lens' CreateElasticsearchDomain (Maybe AutoTuneOptionsInput)
createElasticsearchDomain_autoTuneOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe AutoTuneOptionsInput
autoTuneOptions :: Maybe AutoTuneOptionsInput
$sel:autoTuneOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AutoTuneOptionsInput
autoTuneOptions} -> Maybe AutoTuneOptionsInput
autoTuneOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe AutoTuneOptionsInput
a -> CreateElasticsearchDomain
s {$sel:autoTuneOptions:CreateElasticsearchDomain' :: Maybe AutoTuneOptionsInput
autoTuneOptions = Maybe AutoTuneOptionsInput
a} :: CreateElasticsearchDomain)

-- | Options to specify the Cognito user and identity pools for Kibana
-- authentication. For more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-cognito-auth.html Amazon Cognito Authentication for Kibana>.
createElasticsearchDomain_cognitoOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe CognitoOptions)
createElasticsearchDomain_cognitoOptions :: Lens' CreateElasticsearchDomain (Maybe CognitoOptions)
createElasticsearchDomain_cognitoOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe CognitoOptions
cognitoOptions :: Maybe CognitoOptions
$sel:cognitoOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe CognitoOptions
cognitoOptions} -> Maybe CognitoOptions
cognitoOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe CognitoOptions
a -> CreateElasticsearchDomain
s {$sel:cognitoOptions:CreateElasticsearchDomain' :: Maybe CognitoOptions
cognitoOptions = Maybe CognitoOptions
a} :: CreateElasticsearchDomain)

-- | Options to specify configuration that will be applied to the domain
-- endpoint.
createElasticsearchDomain_domainEndpointOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe DomainEndpointOptions)
createElasticsearchDomain_domainEndpointOptions :: Lens' CreateElasticsearchDomain (Maybe DomainEndpointOptions)
createElasticsearchDomain_domainEndpointOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe DomainEndpointOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
$sel:domainEndpointOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe DomainEndpointOptions
domainEndpointOptions} -> Maybe DomainEndpointOptions
domainEndpointOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe DomainEndpointOptions
a -> CreateElasticsearchDomain
s {$sel:domainEndpointOptions:CreateElasticsearchDomain' :: Maybe DomainEndpointOptions
domainEndpointOptions = Maybe DomainEndpointOptions
a} :: CreateElasticsearchDomain)

-- | Options to enable, disable and specify the type and size of EBS storage
-- volumes.
createElasticsearchDomain_eBSOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe EBSOptions)
createElasticsearchDomain_eBSOptions :: Lens' CreateElasticsearchDomain (Maybe EBSOptions)
createElasticsearchDomain_eBSOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe EBSOptions
eBSOptions :: Maybe EBSOptions
$sel:eBSOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EBSOptions
eBSOptions} -> Maybe EBSOptions
eBSOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe EBSOptions
a -> CreateElasticsearchDomain
s {$sel:eBSOptions:CreateElasticsearchDomain' :: Maybe EBSOptions
eBSOptions = Maybe EBSOptions
a} :: CreateElasticsearchDomain)

-- | Configuration options for an Elasticsearch domain. Specifies the
-- instance type and number of instances in the domain cluster.
createElasticsearchDomain_elasticsearchClusterConfig :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe ElasticsearchClusterConfig)
createElasticsearchDomain_elasticsearchClusterConfig :: Lens' CreateElasticsearchDomain (Maybe ElasticsearchClusterConfig)
createElasticsearchDomain_elasticsearchClusterConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig :: Maybe ElasticsearchClusterConfig
$sel:elasticsearchClusterConfig:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig} -> Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe ElasticsearchClusterConfig
a -> CreateElasticsearchDomain
s {$sel:elasticsearchClusterConfig:CreateElasticsearchDomain' :: Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig = Maybe ElasticsearchClusterConfig
a} :: CreateElasticsearchDomain)

-- | String of format X.Y to specify version for the Elasticsearch domain eg.
-- \"1.5\" or \"2.3\". For more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomains Creating Elasticsearch Domains>
-- in the /Amazon Elasticsearch Service Developer Guide/.
createElasticsearchDomain_elasticsearchVersion :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe Prelude.Text)
createElasticsearchDomain_elasticsearchVersion :: Lens' CreateElasticsearchDomain (Maybe Text)
createElasticsearchDomain_elasticsearchVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe Text
elasticsearchVersion :: Maybe Text
$sel:elasticsearchVersion:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe Text
elasticsearchVersion} -> Maybe Text
elasticsearchVersion) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe Text
a -> CreateElasticsearchDomain
s {$sel:elasticsearchVersion:CreateElasticsearchDomain' :: Maybe Text
elasticsearchVersion = Maybe Text
a} :: CreateElasticsearchDomain)

-- | Specifies the Encryption At Rest Options.
createElasticsearchDomain_encryptionAtRestOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe EncryptionAtRestOptions)
createElasticsearchDomain_encryptionAtRestOptions :: Lens' CreateElasticsearchDomain (Maybe EncryptionAtRestOptions)
createElasticsearchDomain_encryptionAtRestOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe EncryptionAtRestOptions
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
$sel:encryptionAtRestOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EncryptionAtRestOptions
encryptionAtRestOptions} -> Maybe EncryptionAtRestOptions
encryptionAtRestOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe EncryptionAtRestOptions
a -> CreateElasticsearchDomain
s {$sel:encryptionAtRestOptions:CreateElasticsearchDomain' :: Maybe EncryptionAtRestOptions
encryptionAtRestOptions = Maybe EncryptionAtRestOptions
a} :: CreateElasticsearchDomain)

-- | Map of @LogType@ and @LogPublishingOption@, each containing options to
-- publish a given type of Elasticsearch log.
createElasticsearchDomain_logPublishingOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe (Prelude.HashMap LogType LogPublishingOption))
createElasticsearchDomain_logPublishingOptions :: Lens'
  CreateElasticsearchDomain
  (Maybe (HashMap LogType LogPublishingOption))
createElasticsearchDomain_logPublishingOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
$sel:logPublishingOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain
-> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions} -> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe (HashMap LogType LogPublishingOption)
a -> CreateElasticsearchDomain
s {$sel:logPublishingOptions:CreateElasticsearchDomain' :: Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions = Maybe (HashMap LogType LogPublishingOption)
a} :: CreateElasticsearchDomain) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies the NodeToNodeEncryptionOptions.
createElasticsearchDomain_nodeToNodeEncryptionOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe NodeToNodeEncryptionOptions)
createElasticsearchDomain_nodeToNodeEncryptionOptions :: Lens' CreateElasticsearchDomain (Maybe NodeToNodeEncryptionOptions)
createElasticsearchDomain_nodeToNodeEncryptionOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
$sel:nodeToNodeEncryptionOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions} -> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe NodeToNodeEncryptionOptions
a -> CreateElasticsearchDomain
s {$sel:nodeToNodeEncryptionOptions:CreateElasticsearchDomain' :: Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions = Maybe NodeToNodeEncryptionOptions
a} :: CreateElasticsearchDomain)

-- | Option to set time, in UTC format, of the daily automated snapshot.
-- Default value is 0 hours.
createElasticsearchDomain_snapshotOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe SnapshotOptions)
createElasticsearchDomain_snapshotOptions :: Lens' CreateElasticsearchDomain (Maybe SnapshotOptions)
createElasticsearchDomain_snapshotOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe SnapshotOptions
snapshotOptions :: Maybe SnapshotOptions
$sel:snapshotOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe SnapshotOptions
snapshotOptions} -> Maybe SnapshotOptions
snapshotOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe SnapshotOptions
a -> CreateElasticsearchDomain
s {$sel:snapshotOptions:CreateElasticsearchDomain' :: Maybe SnapshotOptions
snapshotOptions = Maybe SnapshotOptions
a} :: CreateElasticsearchDomain)

-- | A list of @Tag@ added during domain creation.
createElasticsearchDomain_tagList :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe [Tag])
createElasticsearchDomain_tagList :: Lens' CreateElasticsearchDomain (Maybe [Tag])
createElasticsearchDomain_tagList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe [Tag]
tagList :: Maybe [Tag]
$sel:tagList:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe [Tag]
tagList} -> Maybe [Tag]
tagList) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe [Tag]
a -> CreateElasticsearchDomain
s {$sel:tagList:CreateElasticsearchDomain' :: Maybe [Tag]
tagList = Maybe [Tag]
a} :: CreateElasticsearchDomain) 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

-- | Options to specify the subnets and security groups for VPC endpoint. For
-- more information, see
-- <http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html#es-creating-vpc Creating a VPC>
-- in /VPC Endpoints for Amazon Elasticsearch Service Domains/
createElasticsearchDomain_vPCOptions :: Lens.Lens' CreateElasticsearchDomain (Prelude.Maybe VPCOptions)
createElasticsearchDomain_vPCOptions :: Lens' CreateElasticsearchDomain (Maybe VPCOptions)
createElasticsearchDomain_vPCOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Maybe VPCOptions
vPCOptions :: Maybe VPCOptions
$sel:vPCOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe VPCOptions
vPCOptions} -> Maybe VPCOptions
vPCOptions) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Maybe VPCOptions
a -> CreateElasticsearchDomain
s {$sel:vPCOptions:CreateElasticsearchDomain' :: Maybe VPCOptions
vPCOptions = Maybe VPCOptions
a} :: CreateElasticsearchDomain)

-- | The name of the Elasticsearch domain that you are creating. Domain names
-- are unique across the domains owned by an account within an AWS region.
-- Domain names must start with a lowercase letter and can contain the
-- following characters: a-z (lowercase), 0-9, and - (hyphen).
createElasticsearchDomain_domainName :: Lens.Lens' CreateElasticsearchDomain Prelude.Text
createElasticsearchDomain_domainName :: Lens' CreateElasticsearchDomain Text
createElasticsearchDomain_domainName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomain' {Text
domainName :: Text
$sel:domainName:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Text
domainName} -> Text
domainName) (\s :: CreateElasticsearchDomain
s@CreateElasticsearchDomain' {} Text
a -> CreateElasticsearchDomain
s {$sel:domainName:CreateElasticsearchDomain' :: Text
domainName = Text
a} :: CreateElasticsearchDomain)

instance Core.AWSRequest CreateElasticsearchDomain where
  type
    AWSResponse CreateElasticsearchDomain =
      CreateElasticsearchDomainResponse
  request :: (Service -> Service)
-> CreateElasticsearchDomain -> Request CreateElasticsearchDomain
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateElasticsearchDomain
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateElasticsearchDomain)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe ElasticsearchDomainStatus
-> Int -> CreateElasticsearchDomainResponse
CreateElasticsearchDomainResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"DomainStatus")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateElasticsearchDomain where
  hashWithSalt :: Int -> CreateElasticsearchDomain -> Int
hashWithSalt Int
_salt CreateElasticsearchDomain' {Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap LogType LogPublishingOption)
Maybe CognitoOptions
Maybe EncryptionAtRestOptions
Maybe NodeToNodeEncryptionOptions
Maybe AdvancedSecurityOptionsInput
Maybe SnapshotOptions
Maybe DomainEndpointOptions
Maybe AutoTuneOptionsInput
Maybe VPCOptions
Maybe EBSOptions
Maybe ElasticsearchClusterConfig
Text
domainName :: Text
vPCOptions :: Maybe VPCOptions
tagList :: Maybe [Tag]
snapshotOptions :: Maybe SnapshotOptions
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
elasticsearchVersion :: Maybe Text
elasticsearchClusterConfig :: Maybe ElasticsearchClusterConfig
eBSOptions :: Maybe EBSOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
cognitoOptions :: Maybe CognitoOptions
autoTuneOptions :: Maybe AutoTuneOptionsInput
advancedSecurityOptions :: Maybe AdvancedSecurityOptionsInput
advancedOptions :: Maybe (HashMap Text Text)
accessPolicies :: Maybe Text
$sel:domainName:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Text
$sel:vPCOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe VPCOptions
$sel:tagList:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe [Tag]
$sel:snapshotOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe SnapshotOptions
$sel:nodeToNodeEncryptionOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe NodeToNodeEncryptionOptions
$sel:logPublishingOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain
-> Maybe (HashMap LogType LogPublishingOption)
$sel:encryptionAtRestOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EncryptionAtRestOptions
$sel:elasticsearchVersion:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe Text
$sel:elasticsearchClusterConfig:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe ElasticsearchClusterConfig
$sel:eBSOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EBSOptions
$sel:domainEndpointOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe DomainEndpointOptions
$sel:cognitoOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe CognitoOptions
$sel:autoTuneOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AutoTuneOptionsInput
$sel:advancedSecurityOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AdvancedSecurityOptionsInput
$sel:advancedOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe (HashMap Text Text)
$sel:accessPolicies:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> 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 AdvancedSecurityOptionsInput
advancedSecurityOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AutoTuneOptionsInput
autoTuneOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CognitoOptions
cognitoOptions
      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 ElasticsearchClusterConfig
elasticsearchClusterConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
elasticsearchVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EncryptionAtRestOptions
encryptionAtRestOptions
      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 SnapshotOptions
snapshotOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tagList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VPCOptions
vPCOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domainName

instance Prelude.NFData CreateElasticsearchDomain where
  rnf :: CreateElasticsearchDomain -> ()
rnf CreateElasticsearchDomain' {Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap LogType LogPublishingOption)
Maybe CognitoOptions
Maybe EncryptionAtRestOptions
Maybe NodeToNodeEncryptionOptions
Maybe AdvancedSecurityOptionsInput
Maybe SnapshotOptions
Maybe DomainEndpointOptions
Maybe AutoTuneOptionsInput
Maybe VPCOptions
Maybe EBSOptions
Maybe ElasticsearchClusterConfig
Text
domainName :: Text
vPCOptions :: Maybe VPCOptions
tagList :: Maybe [Tag]
snapshotOptions :: Maybe SnapshotOptions
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
elasticsearchVersion :: Maybe Text
elasticsearchClusterConfig :: Maybe ElasticsearchClusterConfig
eBSOptions :: Maybe EBSOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
cognitoOptions :: Maybe CognitoOptions
autoTuneOptions :: Maybe AutoTuneOptionsInput
advancedSecurityOptions :: Maybe AdvancedSecurityOptionsInput
advancedOptions :: Maybe (HashMap Text Text)
accessPolicies :: Maybe Text
$sel:domainName:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Text
$sel:vPCOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe VPCOptions
$sel:tagList:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe [Tag]
$sel:snapshotOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe SnapshotOptions
$sel:nodeToNodeEncryptionOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe NodeToNodeEncryptionOptions
$sel:logPublishingOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain
-> Maybe (HashMap LogType LogPublishingOption)
$sel:encryptionAtRestOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EncryptionAtRestOptions
$sel:elasticsearchVersion:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe Text
$sel:elasticsearchClusterConfig:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe ElasticsearchClusterConfig
$sel:eBSOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EBSOptions
$sel:domainEndpointOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe DomainEndpointOptions
$sel:cognitoOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe CognitoOptions
$sel:autoTuneOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AutoTuneOptionsInput
$sel:advancedSecurityOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AdvancedSecurityOptionsInput
$sel:advancedOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe (HashMap Text Text)
$sel:accessPolicies:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> 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 AdvancedSecurityOptionsInput
advancedSecurityOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AutoTuneOptionsInput
autoTuneOptions
      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 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 ElasticsearchClusterConfig
elasticsearchClusterConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
elasticsearchVersion
      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 (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 SnapshotOptions
snapshotOptions
      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 VPCOptions
vPCOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domainName

instance Data.ToHeaders CreateElasticsearchDomain where
  toHeaders :: CreateElasticsearchDomain -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToJSON CreateElasticsearchDomain where
  toJSON :: CreateElasticsearchDomain -> Value
toJSON CreateElasticsearchDomain' {Maybe [Tag]
Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap LogType LogPublishingOption)
Maybe CognitoOptions
Maybe EncryptionAtRestOptions
Maybe NodeToNodeEncryptionOptions
Maybe AdvancedSecurityOptionsInput
Maybe SnapshotOptions
Maybe DomainEndpointOptions
Maybe AutoTuneOptionsInput
Maybe VPCOptions
Maybe EBSOptions
Maybe ElasticsearchClusterConfig
Text
domainName :: Text
vPCOptions :: Maybe VPCOptions
tagList :: Maybe [Tag]
snapshotOptions :: Maybe SnapshotOptions
nodeToNodeEncryptionOptions :: Maybe NodeToNodeEncryptionOptions
logPublishingOptions :: Maybe (HashMap LogType LogPublishingOption)
encryptionAtRestOptions :: Maybe EncryptionAtRestOptions
elasticsearchVersion :: Maybe Text
elasticsearchClusterConfig :: Maybe ElasticsearchClusterConfig
eBSOptions :: Maybe EBSOptions
domainEndpointOptions :: Maybe DomainEndpointOptions
cognitoOptions :: Maybe CognitoOptions
autoTuneOptions :: Maybe AutoTuneOptionsInput
advancedSecurityOptions :: Maybe AdvancedSecurityOptionsInput
advancedOptions :: Maybe (HashMap Text Text)
accessPolicies :: Maybe Text
$sel:domainName:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Text
$sel:vPCOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe VPCOptions
$sel:tagList:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe [Tag]
$sel:snapshotOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe SnapshotOptions
$sel:nodeToNodeEncryptionOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe NodeToNodeEncryptionOptions
$sel:logPublishingOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain
-> Maybe (HashMap LogType LogPublishingOption)
$sel:encryptionAtRestOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EncryptionAtRestOptions
$sel:elasticsearchVersion:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe Text
$sel:elasticsearchClusterConfig:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe ElasticsearchClusterConfig
$sel:eBSOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe EBSOptions
$sel:domainEndpointOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe DomainEndpointOptions
$sel:cognitoOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe CognitoOptions
$sel:autoTuneOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AutoTuneOptionsInput
$sel:advancedSecurityOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe AdvancedSecurityOptionsInput
$sel:advancedOptions:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe (HashMap Text Text)
$sel:accessPolicies:CreateElasticsearchDomain' :: CreateElasticsearchDomain -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AccessPolicies" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
accessPolicies,
            (Key
"AdvancedOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
advancedOptions,
            (Key
"AdvancedSecurityOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AdvancedSecurityOptionsInput
advancedSecurityOptions,
            (Key
"AutoTuneOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AutoTuneOptionsInput
autoTuneOptions,
            (Key
"CognitoOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe CognitoOptions
cognitoOptions,
            (Key
"DomainEndpointOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DomainEndpointOptions
domainEndpointOptions,
            (Key
"EBSOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe EBSOptions
eBSOptions,
            (Key
"ElasticsearchClusterConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ElasticsearchClusterConfig
elasticsearchClusterConfig,
            (Key
"ElasticsearchVersion" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
elasticsearchVersion,
            (Key
"EncryptionAtRestOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe EncryptionAtRestOptions
encryptionAtRestOptions,
            (Key
"LogPublishingOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap LogType LogPublishingOption)
logPublishingOptions,
            (Key
"NodeToNodeEncryptionOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe NodeToNodeEncryptionOptions
nodeToNodeEncryptionOptions,
            (Key
"SnapshotOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe SnapshotOptions
snapshotOptions,
            (Key
"TagList" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tagList,
            (Key
"VPCOptions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe VPCOptions
vPCOptions,
            forall a. a -> Maybe a
Prelude.Just (Key
"DomainName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
domainName)
          ]
      )

instance Data.ToPath CreateElasticsearchDomain where
  toPath :: CreateElasticsearchDomain -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/2015-01-01/es/domain"

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

-- | The result of a @CreateElasticsearchDomain@ operation. Contains the
-- status of the newly created Elasticsearch domain.
--
-- /See:/ 'newCreateElasticsearchDomainResponse' smart constructor.
data CreateElasticsearchDomainResponse = CreateElasticsearchDomainResponse'
  { -- | The status of the newly created Elasticsearch domain.
    CreateElasticsearchDomainResponse
-> Maybe ElasticsearchDomainStatus
domainStatus :: Prelude.Maybe ElasticsearchDomainStatus,
    -- | The response's http status code.
    CreateElasticsearchDomainResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateElasticsearchDomainResponse
-> CreateElasticsearchDomainResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateElasticsearchDomainResponse
-> CreateElasticsearchDomainResponse -> Bool
$c/= :: CreateElasticsearchDomainResponse
-> CreateElasticsearchDomainResponse -> Bool
== :: CreateElasticsearchDomainResponse
-> CreateElasticsearchDomainResponse -> Bool
$c== :: CreateElasticsearchDomainResponse
-> CreateElasticsearchDomainResponse -> Bool
Prelude.Eq, ReadPrec [CreateElasticsearchDomainResponse]
ReadPrec CreateElasticsearchDomainResponse
Int -> ReadS CreateElasticsearchDomainResponse
ReadS [CreateElasticsearchDomainResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateElasticsearchDomainResponse]
$creadListPrec :: ReadPrec [CreateElasticsearchDomainResponse]
readPrec :: ReadPrec CreateElasticsearchDomainResponse
$creadPrec :: ReadPrec CreateElasticsearchDomainResponse
readList :: ReadS [CreateElasticsearchDomainResponse]
$creadList :: ReadS [CreateElasticsearchDomainResponse]
readsPrec :: Int -> ReadS CreateElasticsearchDomainResponse
$creadsPrec :: Int -> ReadS CreateElasticsearchDomainResponse
Prelude.Read, Int -> CreateElasticsearchDomainResponse -> ShowS
[CreateElasticsearchDomainResponse] -> ShowS
CreateElasticsearchDomainResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateElasticsearchDomainResponse] -> ShowS
$cshowList :: [CreateElasticsearchDomainResponse] -> ShowS
show :: CreateElasticsearchDomainResponse -> String
$cshow :: CreateElasticsearchDomainResponse -> String
showsPrec :: Int -> CreateElasticsearchDomainResponse -> ShowS
$cshowsPrec :: Int -> CreateElasticsearchDomainResponse -> ShowS
Prelude.Show, forall x.
Rep CreateElasticsearchDomainResponse x
-> CreateElasticsearchDomainResponse
forall x.
CreateElasticsearchDomainResponse
-> Rep CreateElasticsearchDomainResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateElasticsearchDomainResponse x
-> CreateElasticsearchDomainResponse
$cfrom :: forall x.
CreateElasticsearchDomainResponse
-> Rep CreateElasticsearchDomainResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateElasticsearchDomainResponse' 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:
--
-- 'domainStatus', 'createElasticsearchDomainResponse_domainStatus' - The status of the newly created Elasticsearch domain.
--
-- 'httpStatus', 'createElasticsearchDomainResponse_httpStatus' - The response's http status code.
newCreateElasticsearchDomainResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateElasticsearchDomainResponse
newCreateElasticsearchDomainResponse :: Int -> CreateElasticsearchDomainResponse
newCreateElasticsearchDomainResponse Int
pHttpStatus_ =
  CreateElasticsearchDomainResponse'
    { $sel:domainStatus:CreateElasticsearchDomainResponse' :: Maybe ElasticsearchDomainStatus
domainStatus =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateElasticsearchDomainResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The status of the newly created Elasticsearch domain.
createElasticsearchDomainResponse_domainStatus :: Lens.Lens' CreateElasticsearchDomainResponse (Prelude.Maybe ElasticsearchDomainStatus)
createElasticsearchDomainResponse_domainStatus :: Lens'
  CreateElasticsearchDomainResponse (Maybe ElasticsearchDomainStatus)
createElasticsearchDomainResponse_domainStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomainResponse' {Maybe ElasticsearchDomainStatus
domainStatus :: Maybe ElasticsearchDomainStatus
$sel:domainStatus:CreateElasticsearchDomainResponse' :: CreateElasticsearchDomainResponse
-> Maybe ElasticsearchDomainStatus
domainStatus} -> Maybe ElasticsearchDomainStatus
domainStatus) (\s :: CreateElasticsearchDomainResponse
s@CreateElasticsearchDomainResponse' {} Maybe ElasticsearchDomainStatus
a -> CreateElasticsearchDomainResponse
s {$sel:domainStatus:CreateElasticsearchDomainResponse' :: Maybe ElasticsearchDomainStatus
domainStatus = Maybe ElasticsearchDomainStatus
a} :: CreateElasticsearchDomainResponse)

-- | The response's http status code.
createElasticsearchDomainResponse_httpStatus :: Lens.Lens' CreateElasticsearchDomainResponse Prelude.Int
createElasticsearchDomainResponse_httpStatus :: Lens' CreateElasticsearchDomainResponse Int
createElasticsearchDomainResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateElasticsearchDomainResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateElasticsearchDomainResponse' :: CreateElasticsearchDomainResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateElasticsearchDomainResponse
s@CreateElasticsearchDomainResponse' {} Int
a -> CreateElasticsearchDomainResponse
s {$sel:httpStatus:CreateElasticsearchDomainResponse' :: Int
httpStatus = Int
a} :: CreateElasticsearchDomainResponse)

instance
  Prelude.NFData
    CreateElasticsearchDomainResponse
  where
  rnf :: CreateElasticsearchDomainResponse -> ()
rnf CreateElasticsearchDomainResponse' {Int
Maybe ElasticsearchDomainStatus
httpStatus :: Int
domainStatus :: Maybe ElasticsearchDomainStatus
$sel:httpStatus:CreateElasticsearchDomainResponse' :: CreateElasticsearchDomainResponse -> Int
$sel:domainStatus:CreateElasticsearchDomainResponse' :: CreateElasticsearchDomainResponse
-> Maybe ElasticsearchDomainStatus
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ElasticsearchDomainStatus
domainStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus