{-# 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.GlobalAccelerator.CreateCustomRoutingAccelerator
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Create a custom routing accelerator. A custom routing accelerator
-- directs traffic to one of possibly thousands of Amazon EC2 instance
-- destinations running in a single or multiple virtual private clouds
-- (VPC) subnet endpoints.
--
-- Be aware that, by default, all destination EC2 instances in a VPC subnet
-- endpoint cannot receive traffic. To enable all destinations to receive
-- traffic, or to specify individual port mappings that can receive
-- traffic, see the
-- <https://docs.aws.amazon.com/global-accelerator/latest/api/API_AllowCustomRoutingTraffic.html AllowCustomRoutingTraffic>
-- operation.
--
-- Global Accelerator is a global service that supports endpoints in
-- multiple Amazon Web Services Regions but you must specify the US West
-- (Oregon) Region to create, update, or otherwise work with accelerators.
-- That is, for example, specify @--region us-west-2@ on AWS CLI commands.
module Amazonka.GlobalAccelerator.CreateCustomRoutingAccelerator
  ( -- * Creating a Request
    CreateCustomRoutingAccelerator (..),
    newCreateCustomRoutingAccelerator,

    -- * Request Lenses
    createCustomRoutingAccelerator_enabled,
    createCustomRoutingAccelerator_ipAddressType,
    createCustomRoutingAccelerator_ipAddresses,
    createCustomRoutingAccelerator_tags,
    createCustomRoutingAccelerator_name,
    createCustomRoutingAccelerator_idempotencyToken,

    -- * Destructuring the Response
    CreateCustomRoutingAcceleratorResponse (..),
    newCreateCustomRoutingAcceleratorResponse,

    -- * Response Lenses
    createCustomRoutingAcceleratorResponse_accelerator,
    createCustomRoutingAcceleratorResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateCustomRoutingAccelerator' smart constructor.
data CreateCustomRoutingAccelerator = CreateCustomRoutingAccelerator'
  { -- | Indicates whether an accelerator is enabled. The value is true or false.
    -- The default value is true.
    --
    -- If the value is set to true, an accelerator cannot be deleted. If set to
    -- false, the accelerator can be deleted.
    CreateCustomRoutingAccelerator -> Maybe Bool
enabled :: Prelude.Maybe Prelude.Bool,
    -- | The IP address type that an accelerator supports. For a custom routing
    -- accelerator, the value must be IPV4.
    CreateCustomRoutingAccelerator -> Maybe IpAddressType
ipAddressType :: Prelude.Maybe IpAddressType,
    -- | Optionally, if you\'ve added your own IP address pool to Global
    -- Accelerator (BYOIP), you can choose an IPv4 address from your own pool
    -- to use for the accelerator\'s static IPv4 address when you create an
    -- accelerator.
    --
    -- After you bring an address range to Amazon Web Services, it appears in
    -- your account as an address pool. When you create an accelerator, you can
    -- assign one IPv4 address from your range to it. Global Accelerator
    -- assigns you a second static IPv4 address from an Amazon IP address
    -- range. If you bring two IPv4 address ranges to Amazon Web Services, you
    -- can assign one IPv4 address from each range to your accelerator. This
    -- restriction is because Global Accelerator assigns each address range to
    -- a different network zone, for high availability.
    --
    -- You can specify one or two addresses, separated by a space. Do not
    -- include the \/32 suffix.
    --
    -- Note that you can\'t update IP addresses for an existing accelerator. To
    -- change them, you must create a new accelerator with the new addresses.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/global-accelerator/latest/dg/using-byoip.html Bring your own IP addresses (BYOIP)>
    -- in the /Global Accelerator Developer Guide/.
    CreateCustomRoutingAccelerator -> Maybe [Text]
ipAddresses :: Prelude.Maybe [Prelude.Text],
    -- | Create tags for an accelerator.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/global-accelerator/latest/dg/tagging-in-global-accelerator.html Tagging in Global Accelerator>
    -- in the /Global Accelerator Developer Guide/.
    CreateCustomRoutingAccelerator -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of a custom routing accelerator. The name can have a maximum of
    -- 64 characters, must contain only alphanumeric characters or hyphens (-),
    -- and must not begin or end with a hyphen.
    CreateCustomRoutingAccelerator -> Text
name :: Prelude.Text,
    -- | A unique, case-sensitive identifier that you provide to ensure the
    -- idempotency—that is, the uniqueness—of the request.
    CreateCustomRoutingAccelerator -> Text
idempotencyToken :: Prelude.Text
  }
  deriving (CreateCustomRoutingAccelerator
-> CreateCustomRoutingAccelerator -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCustomRoutingAccelerator
-> CreateCustomRoutingAccelerator -> Bool
$c/= :: CreateCustomRoutingAccelerator
-> CreateCustomRoutingAccelerator -> Bool
== :: CreateCustomRoutingAccelerator
-> CreateCustomRoutingAccelerator -> Bool
$c== :: CreateCustomRoutingAccelerator
-> CreateCustomRoutingAccelerator -> Bool
Prelude.Eq, ReadPrec [CreateCustomRoutingAccelerator]
ReadPrec CreateCustomRoutingAccelerator
Int -> ReadS CreateCustomRoutingAccelerator
ReadS [CreateCustomRoutingAccelerator]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCustomRoutingAccelerator]
$creadListPrec :: ReadPrec [CreateCustomRoutingAccelerator]
readPrec :: ReadPrec CreateCustomRoutingAccelerator
$creadPrec :: ReadPrec CreateCustomRoutingAccelerator
readList :: ReadS [CreateCustomRoutingAccelerator]
$creadList :: ReadS [CreateCustomRoutingAccelerator]
readsPrec :: Int -> ReadS CreateCustomRoutingAccelerator
$creadsPrec :: Int -> ReadS CreateCustomRoutingAccelerator
Prelude.Read, Int -> CreateCustomRoutingAccelerator -> ShowS
[CreateCustomRoutingAccelerator] -> ShowS
CreateCustomRoutingAccelerator -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCustomRoutingAccelerator] -> ShowS
$cshowList :: [CreateCustomRoutingAccelerator] -> ShowS
show :: CreateCustomRoutingAccelerator -> String
$cshow :: CreateCustomRoutingAccelerator -> String
showsPrec :: Int -> CreateCustomRoutingAccelerator -> ShowS
$cshowsPrec :: Int -> CreateCustomRoutingAccelerator -> ShowS
Prelude.Show, forall x.
Rep CreateCustomRoutingAccelerator x
-> CreateCustomRoutingAccelerator
forall x.
CreateCustomRoutingAccelerator
-> Rep CreateCustomRoutingAccelerator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateCustomRoutingAccelerator x
-> CreateCustomRoutingAccelerator
$cfrom :: forall x.
CreateCustomRoutingAccelerator
-> Rep CreateCustomRoutingAccelerator x
Prelude.Generic)

-- |
-- Create a value of 'CreateCustomRoutingAccelerator' 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:
--
-- 'enabled', 'createCustomRoutingAccelerator_enabled' - Indicates whether an accelerator is enabled. The value is true or false.
-- The default value is true.
--
-- If the value is set to true, an accelerator cannot be deleted. If set to
-- false, the accelerator can be deleted.
--
-- 'ipAddressType', 'createCustomRoutingAccelerator_ipAddressType' - The IP address type that an accelerator supports. For a custom routing
-- accelerator, the value must be IPV4.
--
-- 'ipAddresses', 'createCustomRoutingAccelerator_ipAddresses' - Optionally, if you\'ve added your own IP address pool to Global
-- Accelerator (BYOIP), you can choose an IPv4 address from your own pool
-- to use for the accelerator\'s static IPv4 address when you create an
-- accelerator.
--
-- After you bring an address range to Amazon Web Services, it appears in
-- your account as an address pool. When you create an accelerator, you can
-- assign one IPv4 address from your range to it. Global Accelerator
-- assigns you a second static IPv4 address from an Amazon IP address
-- range. If you bring two IPv4 address ranges to Amazon Web Services, you
-- can assign one IPv4 address from each range to your accelerator. This
-- restriction is because Global Accelerator assigns each address range to
-- a different network zone, for high availability.
--
-- You can specify one or two addresses, separated by a space. Do not
-- include the \/32 suffix.
--
-- Note that you can\'t update IP addresses for an existing accelerator. To
-- change them, you must create a new accelerator with the new addresses.
--
-- For more information, see
-- <https://docs.aws.amazon.com/global-accelerator/latest/dg/using-byoip.html Bring your own IP addresses (BYOIP)>
-- in the /Global Accelerator Developer Guide/.
--
-- 'tags', 'createCustomRoutingAccelerator_tags' - Create tags for an accelerator.
--
-- For more information, see
-- <https://docs.aws.amazon.com/global-accelerator/latest/dg/tagging-in-global-accelerator.html Tagging in Global Accelerator>
-- in the /Global Accelerator Developer Guide/.
--
-- 'name', 'createCustomRoutingAccelerator_name' - The name of a custom routing accelerator. The name can have a maximum of
-- 64 characters, must contain only alphanumeric characters or hyphens (-),
-- and must not begin or end with a hyphen.
--
-- 'idempotencyToken', 'createCustomRoutingAccelerator_idempotencyToken' - A unique, case-sensitive identifier that you provide to ensure the
-- idempotency—that is, the uniqueness—of the request.
newCreateCustomRoutingAccelerator ::
  -- | 'name'
  Prelude.Text ->
  -- | 'idempotencyToken'
  Prelude.Text ->
  CreateCustomRoutingAccelerator
newCreateCustomRoutingAccelerator :: Text -> Text -> CreateCustomRoutingAccelerator
newCreateCustomRoutingAccelerator
  Text
pName_
  Text
pIdempotencyToken_ =
    CreateCustomRoutingAccelerator'
      { $sel:enabled:CreateCustomRoutingAccelerator' :: Maybe Bool
enabled =
          forall a. Maybe a
Prelude.Nothing,
        $sel:ipAddressType:CreateCustomRoutingAccelerator' :: Maybe IpAddressType
ipAddressType = forall a. Maybe a
Prelude.Nothing,
        $sel:ipAddresses:CreateCustomRoutingAccelerator' :: Maybe [Text]
ipAddresses = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateCustomRoutingAccelerator' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateCustomRoutingAccelerator' :: Text
name = Text
pName_,
        $sel:idempotencyToken:CreateCustomRoutingAccelerator' :: Text
idempotencyToken = Text
pIdempotencyToken_
      }

-- | Indicates whether an accelerator is enabled. The value is true or false.
-- The default value is true.
--
-- If the value is set to true, an accelerator cannot be deleted. If set to
-- false, the accelerator can be deleted.
createCustomRoutingAccelerator_enabled :: Lens.Lens' CreateCustomRoutingAccelerator (Prelude.Maybe Prelude.Bool)
createCustomRoutingAccelerator_enabled :: Lens' CreateCustomRoutingAccelerator (Maybe Bool)
createCustomRoutingAccelerator_enabled = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAccelerator' {Maybe Bool
enabled :: Maybe Bool
$sel:enabled:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe Bool
enabled} -> Maybe Bool
enabled) (\s :: CreateCustomRoutingAccelerator
s@CreateCustomRoutingAccelerator' {} Maybe Bool
a -> CreateCustomRoutingAccelerator
s {$sel:enabled:CreateCustomRoutingAccelerator' :: Maybe Bool
enabled = Maybe Bool
a} :: CreateCustomRoutingAccelerator)

-- | The IP address type that an accelerator supports. For a custom routing
-- accelerator, the value must be IPV4.
createCustomRoutingAccelerator_ipAddressType :: Lens.Lens' CreateCustomRoutingAccelerator (Prelude.Maybe IpAddressType)
createCustomRoutingAccelerator_ipAddressType :: Lens' CreateCustomRoutingAccelerator (Maybe IpAddressType)
createCustomRoutingAccelerator_ipAddressType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAccelerator' {Maybe IpAddressType
ipAddressType :: Maybe IpAddressType
$sel:ipAddressType:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe IpAddressType
ipAddressType} -> Maybe IpAddressType
ipAddressType) (\s :: CreateCustomRoutingAccelerator
s@CreateCustomRoutingAccelerator' {} Maybe IpAddressType
a -> CreateCustomRoutingAccelerator
s {$sel:ipAddressType:CreateCustomRoutingAccelerator' :: Maybe IpAddressType
ipAddressType = Maybe IpAddressType
a} :: CreateCustomRoutingAccelerator)

-- | Optionally, if you\'ve added your own IP address pool to Global
-- Accelerator (BYOIP), you can choose an IPv4 address from your own pool
-- to use for the accelerator\'s static IPv4 address when you create an
-- accelerator.
--
-- After you bring an address range to Amazon Web Services, it appears in
-- your account as an address pool. When you create an accelerator, you can
-- assign one IPv4 address from your range to it. Global Accelerator
-- assigns you a second static IPv4 address from an Amazon IP address
-- range. If you bring two IPv4 address ranges to Amazon Web Services, you
-- can assign one IPv4 address from each range to your accelerator. This
-- restriction is because Global Accelerator assigns each address range to
-- a different network zone, for high availability.
--
-- You can specify one or two addresses, separated by a space. Do not
-- include the \/32 suffix.
--
-- Note that you can\'t update IP addresses for an existing accelerator. To
-- change them, you must create a new accelerator with the new addresses.
--
-- For more information, see
-- <https://docs.aws.amazon.com/global-accelerator/latest/dg/using-byoip.html Bring your own IP addresses (BYOIP)>
-- in the /Global Accelerator Developer Guide/.
createCustomRoutingAccelerator_ipAddresses :: Lens.Lens' CreateCustomRoutingAccelerator (Prelude.Maybe [Prelude.Text])
createCustomRoutingAccelerator_ipAddresses :: Lens' CreateCustomRoutingAccelerator (Maybe [Text])
createCustomRoutingAccelerator_ipAddresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAccelerator' {Maybe [Text]
ipAddresses :: Maybe [Text]
$sel:ipAddresses:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Text]
ipAddresses} -> Maybe [Text]
ipAddresses) (\s :: CreateCustomRoutingAccelerator
s@CreateCustomRoutingAccelerator' {} Maybe [Text]
a -> CreateCustomRoutingAccelerator
s {$sel:ipAddresses:CreateCustomRoutingAccelerator' :: Maybe [Text]
ipAddresses = Maybe [Text]
a} :: CreateCustomRoutingAccelerator) 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

-- | Create tags for an accelerator.
--
-- For more information, see
-- <https://docs.aws.amazon.com/global-accelerator/latest/dg/tagging-in-global-accelerator.html Tagging in Global Accelerator>
-- in the /Global Accelerator Developer Guide/.
createCustomRoutingAccelerator_tags :: Lens.Lens' CreateCustomRoutingAccelerator (Prelude.Maybe [Tag])
createCustomRoutingAccelerator_tags :: Lens' CreateCustomRoutingAccelerator (Maybe [Tag])
createCustomRoutingAccelerator_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAccelerator' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateCustomRoutingAccelerator
s@CreateCustomRoutingAccelerator' {} Maybe [Tag]
a -> CreateCustomRoutingAccelerator
s {$sel:tags:CreateCustomRoutingAccelerator' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateCustomRoutingAccelerator) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of a custom routing accelerator. The name can have a maximum of
-- 64 characters, must contain only alphanumeric characters or hyphens (-),
-- and must not begin or end with a hyphen.
createCustomRoutingAccelerator_name :: Lens.Lens' CreateCustomRoutingAccelerator Prelude.Text
createCustomRoutingAccelerator_name :: Lens' CreateCustomRoutingAccelerator Text
createCustomRoutingAccelerator_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAccelerator' {Text
name :: Text
$sel:name:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
name} -> Text
name) (\s :: CreateCustomRoutingAccelerator
s@CreateCustomRoutingAccelerator' {} Text
a -> CreateCustomRoutingAccelerator
s {$sel:name:CreateCustomRoutingAccelerator' :: Text
name = Text
a} :: CreateCustomRoutingAccelerator)

-- | A unique, case-sensitive identifier that you provide to ensure the
-- idempotency—that is, the uniqueness—of the request.
createCustomRoutingAccelerator_idempotencyToken :: Lens.Lens' CreateCustomRoutingAccelerator Prelude.Text
createCustomRoutingAccelerator_idempotencyToken :: Lens' CreateCustomRoutingAccelerator Text
createCustomRoutingAccelerator_idempotencyToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAccelerator' {Text
idempotencyToken :: Text
$sel:idempotencyToken:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
idempotencyToken} -> Text
idempotencyToken) (\s :: CreateCustomRoutingAccelerator
s@CreateCustomRoutingAccelerator' {} Text
a -> CreateCustomRoutingAccelerator
s {$sel:idempotencyToken:CreateCustomRoutingAccelerator' :: Text
idempotencyToken = Text
a} :: CreateCustomRoutingAccelerator)

instance
  Core.AWSRequest
    CreateCustomRoutingAccelerator
  where
  type
    AWSResponse CreateCustomRoutingAccelerator =
      CreateCustomRoutingAcceleratorResponse
  request :: (Service -> Service)
-> CreateCustomRoutingAccelerator
-> Request CreateCustomRoutingAccelerator
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 CreateCustomRoutingAccelerator
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateCustomRoutingAccelerator)))
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 CustomRoutingAccelerator
-> Int -> CreateCustomRoutingAcceleratorResponse
CreateCustomRoutingAcceleratorResponse'
            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
"Accelerator")
            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
    CreateCustomRoutingAccelerator
  where
  hashWithSalt :: Int -> CreateCustomRoutingAccelerator -> Int
hashWithSalt
    Int
_salt
    CreateCustomRoutingAccelerator' {Maybe Bool
Maybe [Text]
Maybe [Tag]
Maybe IpAddressType
Text
idempotencyToken :: Text
name :: Text
tags :: Maybe [Tag]
ipAddresses :: Maybe [Text]
ipAddressType :: Maybe IpAddressType
enabled :: Maybe Bool
$sel:idempotencyToken:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
$sel:name:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
$sel:tags:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Tag]
$sel:ipAddresses:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Text]
$sel:ipAddressType:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe IpAddressType
$sel:enabled:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe Bool
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
enabled
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe IpAddressType
ipAddressType
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
ipAddresses
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
idempotencyToken

instance
  Prelude.NFData
    CreateCustomRoutingAccelerator
  where
  rnf :: CreateCustomRoutingAccelerator -> ()
rnf CreateCustomRoutingAccelerator' {Maybe Bool
Maybe [Text]
Maybe [Tag]
Maybe IpAddressType
Text
idempotencyToken :: Text
name :: Text
tags :: Maybe [Tag]
ipAddresses :: Maybe [Text]
ipAddressType :: Maybe IpAddressType
enabled :: Maybe Bool
$sel:idempotencyToken:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
$sel:name:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
$sel:tags:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Tag]
$sel:ipAddresses:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Text]
$sel:ipAddressType:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe IpAddressType
$sel:enabled:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
enabled
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe IpAddressType
ipAddressType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
ipAddresses
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
idempotencyToken

instance
  Data.ToHeaders
    CreateCustomRoutingAccelerator
  where
  toHeaders :: CreateCustomRoutingAccelerator -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateCustomRoutingAccelerator where
  toJSON :: CreateCustomRoutingAccelerator -> Value
toJSON CreateCustomRoutingAccelerator' {Maybe Bool
Maybe [Text]
Maybe [Tag]
Maybe IpAddressType
Text
idempotencyToken :: Text
name :: Text
tags :: Maybe [Tag]
ipAddresses :: Maybe [Text]
ipAddressType :: Maybe IpAddressType
enabled :: Maybe Bool
$sel:idempotencyToken:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
$sel:name:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Text
$sel:tags:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Tag]
$sel:ipAddresses:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe [Text]
$sel:ipAddressType:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe IpAddressType
$sel:enabled:CreateCustomRoutingAccelerator' :: CreateCustomRoutingAccelerator -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Enabled" 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 Bool
enabled,
            (Key
"IpAddressType" 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 IpAddressType
ipAddressType,
            (Key
"IpAddresses" 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]
ipAddresses,
            (Key
"Tags" 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]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"IdempotencyToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
idempotencyToken)
          ]
      )

instance Data.ToPath CreateCustomRoutingAccelerator where
  toPath :: CreateCustomRoutingAccelerator -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | /See:/ 'newCreateCustomRoutingAcceleratorResponse' smart constructor.
data CreateCustomRoutingAcceleratorResponse = CreateCustomRoutingAcceleratorResponse'
  { -- | The accelerator that is created.
    CreateCustomRoutingAcceleratorResponse
-> Maybe CustomRoutingAccelerator
accelerator :: Prelude.Maybe CustomRoutingAccelerator,
    -- | The response's http status code.
    CreateCustomRoutingAcceleratorResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateCustomRoutingAcceleratorResponse
-> CreateCustomRoutingAcceleratorResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCustomRoutingAcceleratorResponse
-> CreateCustomRoutingAcceleratorResponse -> Bool
$c/= :: CreateCustomRoutingAcceleratorResponse
-> CreateCustomRoutingAcceleratorResponse -> Bool
== :: CreateCustomRoutingAcceleratorResponse
-> CreateCustomRoutingAcceleratorResponse -> Bool
$c== :: CreateCustomRoutingAcceleratorResponse
-> CreateCustomRoutingAcceleratorResponse -> Bool
Prelude.Eq, ReadPrec [CreateCustomRoutingAcceleratorResponse]
ReadPrec CreateCustomRoutingAcceleratorResponse
Int -> ReadS CreateCustomRoutingAcceleratorResponse
ReadS [CreateCustomRoutingAcceleratorResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCustomRoutingAcceleratorResponse]
$creadListPrec :: ReadPrec [CreateCustomRoutingAcceleratorResponse]
readPrec :: ReadPrec CreateCustomRoutingAcceleratorResponse
$creadPrec :: ReadPrec CreateCustomRoutingAcceleratorResponse
readList :: ReadS [CreateCustomRoutingAcceleratorResponse]
$creadList :: ReadS [CreateCustomRoutingAcceleratorResponse]
readsPrec :: Int -> ReadS CreateCustomRoutingAcceleratorResponse
$creadsPrec :: Int -> ReadS CreateCustomRoutingAcceleratorResponse
Prelude.Read, Int -> CreateCustomRoutingAcceleratorResponse -> ShowS
[CreateCustomRoutingAcceleratorResponse] -> ShowS
CreateCustomRoutingAcceleratorResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCustomRoutingAcceleratorResponse] -> ShowS
$cshowList :: [CreateCustomRoutingAcceleratorResponse] -> ShowS
show :: CreateCustomRoutingAcceleratorResponse -> String
$cshow :: CreateCustomRoutingAcceleratorResponse -> String
showsPrec :: Int -> CreateCustomRoutingAcceleratorResponse -> ShowS
$cshowsPrec :: Int -> CreateCustomRoutingAcceleratorResponse -> ShowS
Prelude.Show, forall x.
Rep CreateCustomRoutingAcceleratorResponse x
-> CreateCustomRoutingAcceleratorResponse
forall x.
CreateCustomRoutingAcceleratorResponse
-> Rep CreateCustomRoutingAcceleratorResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateCustomRoutingAcceleratorResponse x
-> CreateCustomRoutingAcceleratorResponse
$cfrom :: forall x.
CreateCustomRoutingAcceleratorResponse
-> Rep CreateCustomRoutingAcceleratorResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateCustomRoutingAcceleratorResponse' 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:
--
-- 'accelerator', 'createCustomRoutingAcceleratorResponse_accelerator' - The accelerator that is created.
--
-- 'httpStatus', 'createCustomRoutingAcceleratorResponse_httpStatus' - The response's http status code.
newCreateCustomRoutingAcceleratorResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateCustomRoutingAcceleratorResponse
newCreateCustomRoutingAcceleratorResponse :: Int -> CreateCustomRoutingAcceleratorResponse
newCreateCustomRoutingAcceleratorResponse
  Int
pHttpStatus_ =
    CreateCustomRoutingAcceleratorResponse'
      { $sel:accelerator:CreateCustomRoutingAcceleratorResponse' :: Maybe CustomRoutingAccelerator
accelerator =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateCustomRoutingAcceleratorResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | The accelerator that is created.
createCustomRoutingAcceleratorResponse_accelerator :: Lens.Lens' CreateCustomRoutingAcceleratorResponse (Prelude.Maybe CustomRoutingAccelerator)
createCustomRoutingAcceleratorResponse_accelerator :: Lens'
  CreateCustomRoutingAcceleratorResponse
  (Maybe CustomRoutingAccelerator)
createCustomRoutingAcceleratorResponse_accelerator = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCustomRoutingAcceleratorResponse' {Maybe CustomRoutingAccelerator
accelerator :: Maybe CustomRoutingAccelerator
$sel:accelerator:CreateCustomRoutingAcceleratorResponse' :: CreateCustomRoutingAcceleratorResponse
-> Maybe CustomRoutingAccelerator
accelerator} -> Maybe CustomRoutingAccelerator
accelerator) (\s :: CreateCustomRoutingAcceleratorResponse
s@CreateCustomRoutingAcceleratorResponse' {} Maybe CustomRoutingAccelerator
a -> CreateCustomRoutingAcceleratorResponse
s {$sel:accelerator:CreateCustomRoutingAcceleratorResponse' :: Maybe CustomRoutingAccelerator
accelerator = Maybe CustomRoutingAccelerator
a} :: CreateCustomRoutingAcceleratorResponse)

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

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