{-# 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.EC2.ProvisionByoipCidr
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Provisions an IPv4 or IPv6 address range for use with your Amazon Web
-- Services resources through bring your own IP addresses (BYOIP) and
-- creates a corresponding address pool. After the address range is
-- provisioned, it is ready to be advertised using AdvertiseByoipCidr.
--
-- Amazon Web Services verifies that you own the address range and are
-- authorized to advertise it. You must ensure that the address range is
-- registered to you and that you created an RPKI ROA to authorize Amazon
-- ASNs 16509 and 14618 to advertise the address range. For more
-- information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html Bring your own IP addresses (BYOIP)>
-- in the /Amazon Elastic Compute Cloud User Guide/.
--
-- Provisioning an address range is an asynchronous operation, so the call
-- returns immediately, but the address range is not ready to use until its
-- status changes from @pending-provision@ to @provisioned@. To monitor the
-- status of an address range, use DescribeByoipCidrs. To allocate an
-- Elastic IP address from your IPv4 address pool, use AllocateAddress with
-- either the specific address from the address pool or the ID of the
-- address pool.
module Amazonka.EC2.ProvisionByoipCidr
  ( -- * Creating a Request
    ProvisionByoipCidr (..),
    newProvisionByoipCidr,

    -- * Request Lenses
    provisionByoipCidr_cidrAuthorizationContext,
    provisionByoipCidr_description,
    provisionByoipCidr_dryRun,
    provisionByoipCidr_multiRegion,
    provisionByoipCidr_poolTagSpecifications,
    provisionByoipCidr_publiclyAdvertisable,
    provisionByoipCidr_cidr,

    -- * Destructuring the Response
    ProvisionByoipCidrResponse (..),
    newProvisionByoipCidrResponse,

    -- * Response Lenses
    provisionByoipCidrResponse_byoipCidr,
    provisionByoipCidrResponse_httpStatus,
  )
where

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

-- | /See:/ 'newProvisionByoipCidr' smart constructor.
data ProvisionByoipCidr = ProvisionByoipCidr'
  { -- | A signed document that proves that you are authorized to bring the
    -- specified IP address range to Amazon using BYOIP.
    ProvisionByoipCidr -> Maybe CidrAuthorizationContext
cidrAuthorizationContext :: Prelude.Maybe CidrAuthorizationContext,
    -- | A description for the address range and the address pool.
    ProvisionByoipCidr -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    ProvisionByoipCidr -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | Reserved.
    ProvisionByoipCidr -> Maybe Bool
multiRegion :: Prelude.Maybe Prelude.Bool,
    -- | The tags to apply to the address pool.
    ProvisionByoipCidr -> Maybe [TagSpecification]
poolTagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | (IPv6 only) Indicate whether the address range will be publicly
    -- advertised to the internet.
    --
    -- Default: true
    ProvisionByoipCidr -> Maybe Bool
publiclyAdvertisable :: Prelude.Maybe Prelude.Bool,
    -- | The public IPv4 or IPv6 address range, in CIDR notation. The most
    -- specific IPv4 prefix that you can specify is \/24. The most specific
    -- IPv6 prefix you can specify is \/56. The address range cannot overlap
    -- with another address range that you\'ve brought to this or another
    -- Region.
    ProvisionByoipCidr -> Text
cidr :: Prelude.Text
  }
  deriving (ProvisionByoipCidr -> ProvisionByoipCidr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProvisionByoipCidr -> ProvisionByoipCidr -> Bool
$c/= :: ProvisionByoipCidr -> ProvisionByoipCidr -> Bool
== :: ProvisionByoipCidr -> ProvisionByoipCidr -> Bool
$c== :: ProvisionByoipCidr -> ProvisionByoipCidr -> Bool
Prelude.Eq, ReadPrec [ProvisionByoipCidr]
ReadPrec ProvisionByoipCidr
Int -> ReadS ProvisionByoipCidr
ReadS [ProvisionByoipCidr]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ProvisionByoipCidr]
$creadListPrec :: ReadPrec [ProvisionByoipCidr]
readPrec :: ReadPrec ProvisionByoipCidr
$creadPrec :: ReadPrec ProvisionByoipCidr
readList :: ReadS [ProvisionByoipCidr]
$creadList :: ReadS [ProvisionByoipCidr]
readsPrec :: Int -> ReadS ProvisionByoipCidr
$creadsPrec :: Int -> ReadS ProvisionByoipCidr
Prelude.Read, Int -> ProvisionByoipCidr -> ShowS
[ProvisionByoipCidr] -> ShowS
ProvisionByoipCidr -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProvisionByoipCidr] -> ShowS
$cshowList :: [ProvisionByoipCidr] -> ShowS
show :: ProvisionByoipCidr -> String
$cshow :: ProvisionByoipCidr -> String
showsPrec :: Int -> ProvisionByoipCidr -> ShowS
$cshowsPrec :: Int -> ProvisionByoipCidr -> ShowS
Prelude.Show, forall x. Rep ProvisionByoipCidr x -> ProvisionByoipCidr
forall x. ProvisionByoipCidr -> Rep ProvisionByoipCidr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProvisionByoipCidr x -> ProvisionByoipCidr
$cfrom :: forall x. ProvisionByoipCidr -> Rep ProvisionByoipCidr x
Prelude.Generic)

-- |
-- Create a value of 'ProvisionByoipCidr' 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:
--
-- 'cidrAuthorizationContext', 'provisionByoipCidr_cidrAuthorizationContext' - A signed document that proves that you are authorized to bring the
-- specified IP address range to Amazon using BYOIP.
--
-- 'description', 'provisionByoipCidr_description' - A description for the address range and the address pool.
--
-- 'dryRun', 'provisionByoipCidr_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'multiRegion', 'provisionByoipCidr_multiRegion' - Reserved.
--
-- 'poolTagSpecifications', 'provisionByoipCidr_poolTagSpecifications' - The tags to apply to the address pool.
--
-- 'publiclyAdvertisable', 'provisionByoipCidr_publiclyAdvertisable' - (IPv6 only) Indicate whether the address range will be publicly
-- advertised to the internet.
--
-- Default: true
--
-- 'cidr', 'provisionByoipCidr_cidr' - The public IPv4 or IPv6 address range, in CIDR notation. The most
-- specific IPv4 prefix that you can specify is \/24. The most specific
-- IPv6 prefix you can specify is \/56. The address range cannot overlap
-- with another address range that you\'ve brought to this or another
-- Region.
newProvisionByoipCidr ::
  -- | 'cidr'
  Prelude.Text ->
  ProvisionByoipCidr
newProvisionByoipCidr :: Text -> ProvisionByoipCidr
newProvisionByoipCidr Text
pCidr_ =
  ProvisionByoipCidr'
    { $sel:cidrAuthorizationContext:ProvisionByoipCidr' :: Maybe CidrAuthorizationContext
cidrAuthorizationContext =
        forall a. Maybe a
Prelude.Nothing,
      $sel:description:ProvisionByoipCidr' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:dryRun:ProvisionByoipCidr' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:multiRegion:ProvisionByoipCidr' :: Maybe Bool
multiRegion = forall a. Maybe a
Prelude.Nothing,
      $sel:poolTagSpecifications:ProvisionByoipCidr' :: Maybe [TagSpecification]
poolTagSpecifications = forall a. Maybe a
Prelude.Nothing,
      $sel:publiclyAdvertisable:ProvisionByoipCidr' :: Maybe Bool
publiclyAdvertisable = forall a. Maybe a
Prelude.Nothing,
      $sel:cidr:ProvisionByoipCidr' :: Text
cidr = Text
pCidr_
    }

-- | A signed document that proves that you are authorized to bring the
-- specified IP address range to Amazon using BYOIP.
provisionByoipCidr_cidrAuthorizationContext :: Lens.Lens' ProvisionByoipCidr (Prelude.Maybe CidrAuthorizationContext)
provisionByoipCidr_cidrAuthorizationContext :: Lens' ProvisionByoipCidr (Maybe CidrAuthorizationContext)
provisionByoipCidr_cidrAuthorizationContext = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Maybe CidrAuthorizationContext
cidrAuthorizationContext :: Maybe CidrAuthorizationContext
$sel:cidrAuthorizationContext:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe CidrAuthorizationContext
cidrAuthorizationContext} -> Maybe CidrAuthorizationContext
cidrAuthorizationContext) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Maybe CidrAuthorizationContext
a -> ProvisionByoipCidr
s {$sel:cidrAuthorizationContext:ProvisionByoipCidr' :: Maybe CidrAuthorizationContext
cidrAuthorizationContext = Maybe CidrAuthorizationContext
a} :: ProvisionByoipCidr)

-- | A description for the address range and the address pool.
provisionByoipCidr_description :: Lens.Lens' ProvisionByoipCidr (Prelude.Maybe Prelude.Text)
provisionByoipCidr_description :: Lens' ProvisionByoipCidr (Maybe Text)
provisionByoipCidr_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Maybe Text
description :: Maybe Text
$sel:description:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Text
description} -> Maybe Text
description) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Maybe Text
a -> ProvisionByoipCidr
s {$sel:description:ProvisionByoipCidr' :: Maybe Text
description = Maybe Text
a} :: ProvisionByoipCidr)

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
provisionByoipCidr_dryRun :: Lens.Lens' ProvisionByoipCidr (Prelude.Maybe Prelude.Bool)
provisionByoipCidr_dryRun :: Lens' ProvisionByoipCidr (Maybe Bool)
provisionByoipCidr_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Maybe Bool
a -> ProvisionByoipCidr
s {$sel:dryRun:ProvisionByoipCidr' :: Maybe Bool
dryRun = Maybe Bool
a} :: ProvisionByoipCidr)

-- | Reserved.
provisionByoipCidr_multiRegion :: Lens.Lens' ProvisionByoipCidr (Prelude.Maybe Prelude.Bool)
provisionByoipCidr_multiRegion :: Lens' ProvisionByoipCidr (Maybe Bool)
provisionByoipCidr_multiRegion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Maybe Bool
multiRegion :: Maybe Bool
$sel:multiRegion:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
multiRegion} -> Maybe Bool
multiRegion) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Maybe Bool
a -> ProvisionByoipCidr
s {$sel:multiRegion:ProvisionByoipCidr' :: Maybe Bool
multiRegion = Maybe Bool
a} :: ProvisionByoipCidr)

-- | The tags to apply to the address pool.
provisionByoipCidr_poolTagSpecifications :: Lens.Lens' ProvisionByoipCidr (Prelude.Maybe [TagSpecification])
provisionByoipCidr_poolTagSpecifications :: Lens' ProvisionByoipCidr (Maybe [TagSpecification])
provisionByoipCidr_poolTagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Maybe [TagSpecification]
poolTagSpecifications :: Maybe [TagSpecification]
$sel:poolTagSpecifications:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe [TagSpecification]
poolTagSpecifications} -> Maybe [TagSpecification]
poolTagSpecifications) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Maybe [TagSpecification]
a -> ProvisionByoipCidr
s {$sel:poolTagSpecifications:ProvisionByoipCidr' :: Maybe [TagSpecification]
poolTagSpecifications = Maybe [TagSpecification]
a} :: ProvisionByoipCidr) 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

-- | (IPv6 only) Indicate whether the address range will be publicly
-- advertised to the internet.
--
-- Default: true
provisionByoipCidr_publiclyAdvertisable :: Lens.Lens' ProvisionByoipCidr (Prelude.Maybe Prelude.Bool)
provisionByoipCidr_publiclyAdvertisable :: Lens' ProvisionByoipCidr (Maybe Bool)
provisionByoipCidr_publiclyAdvertisable = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Maybe Bool
publiclyAdvertisable :: Maybe Bool
$sel:publiclyAdvertisable:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
publiclyAdvertisable} -> Maybe Bool
publiclyAdvertisable) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Maybe Bool
a -> ProvisionByoipCidr
s {$sel:publiclyAdvertisable:ProvisionByoipCidr' :: Maybe Bool
publiclyAdvertisable = Maybe Bool
a} :: ProvisionByoipCidr)

-- | The public IPv4 or IPv6 address range, in CIDR notation. The most
-- specific IPv4 prefix that you can specify is \/24. The most specific
-- IPv6 prefix you can specify is \/56. The address range cannot overlap
-- with another address range that you\'ve brought to this or another
-- Region.
provisionByoipCidr_cidr :: Lens.Lens' ProvisionByoipCidr Prelude.Text
provisionByoipCidr_cidr :: Lens' ProvisionByoipCidr Text
provisionByoipCidr_cidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidr' {Text
cidr :: Text
$sel:cidr:ProvisionByoipCidr' :: ProvisionByoipCidr -> Text
cidr} -> Text
cidr) (\s :: ProvisionByoipCidr
s@ProvisionByoipCidr' {} Text
a -> ProvisionByoipCidr
s {$sel:cidr:ProvisionByoipCidr' :: Text
cidr = Text
a} :: ProvisionByoipCidr)

instance Core.AWSRequest ProvisionByoipCidr where
  type
    AWSResponse ProvisionByoipCidr =
      ProvisionByoipCidrResponse
  request :: (Service -> Service)
-> ProvisionByoipCidr -> Request ProvisionByoipCidr
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ProvisionByoipCidr
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ProvisionByoipCidr)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe ByoipCidr -> Int -> ProvisionByoipCidrResponse
ProvisionByoipCidrResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"byoipCidr")
            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 ProvisionByoipCidr where
  hashWithSalt :: Int -> ProvisionByoipCidr -> Int
hashWithSalt Int
_salt ProvisionByoipCidr' {Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe CidrAuthorizationContext
Text
cidr :: Text
publiclyAdvertisable :: Maybe Bool
poolTagSpecifications :: Maybe [TagSpecification]
multiRegion :: Maybe Bool
dryRun :: Maybe Bool
description :: Maybe Text
cidrAuthorizationContext :: Maybe CidrAuthorizationContext
$sel:cidr:ProvisionByoipCidr' :: ProvisionByoipCidr -> Text
$sel:publiclyAdvertisable:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:poolTagSpecifications:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe [TagSpecification]
$sel:multiRegion:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:dryRun:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:description:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Text
$sel:cidrAuthorizationContext:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe CidrAuthorizationContext
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CidrAuthorizationContext
cidrAuthorizationContext
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
multiRegion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TagSpecification]
poolTagSpecifications
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
publiclyAdvertisable
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
cidr

instance Prelude.NFData ProvisionByoipCidr where
  rnf :: ProvisionByoipCidr -> ()
rnf ProvisionByoipCidr' {Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe CidrAuthorizationContext
Text
cidr :: Text
publiclyAdvertisable :: Maybe Bool
poolTagSpecifications :: Maybe [TagSpecification]
multiRegion :: Maybe Bool
dryRun :: Maybe Bool
description :: Maybe Text
cidrAuthorizationContext :: Maybe CidrAuthorizationContext
$sel:cidr:ProvisionByoipCidr' :: ProvisionByoipCidr -> Text
$sel:publiclyAdvertisable:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:poolTagSpecifications:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe [TagSpecification]
$sel:multiRegion:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:dryRun:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:description:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Text
$sel:cidrAuthorizationContext:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe CidrAuthorizationContext
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CidrAuthorizationContext
cidrAuthorizationContext
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
multiRegion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TagSpecification]
poolTagSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
publiclyAdvertisable
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
cidr

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

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

instance Data.ToQuery ProvisionByoipCidr where
  toQuery :: ProvisionByoipCidr -> QueryString
toQuery ProvisionByoipCidr' {Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe CidrAuthorizationContext
Text
cidr :: Text
publiclyAdvertisable :: Maybe Bool
poolTagSpecifications :: Maybe [TagSpecification]
multiRegion :: Maybe Bool
dryRun :: Maybe Bool
description :: Maybe Text
cidrAuthorizationContext :: Maybe CidrAuthorizationContext
$sel:cidr:ProvisionByoipCidr' :: ProvisionByoipCidr -> Text
$sel:publiclyAdvertisable:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:poolTagSpecifications:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe [TagSpecification]
$sel:multiRegion:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:dryRun:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Bool
$sel:description:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe Text
$sel:cidrAuthorizationContext:ProvisionByoipCidr' :: ProvisionByoipCidr -> Maybe CidrAuthorizationContext
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ProvisionByoipCidr" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"CidrAuthorizationContext"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe CidrAuthorizationContext
cidrAuthorizationContext,
        ByteString
"Description" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
description,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"MultiRegion" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
multiRegion,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"PoolTagSpecification"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [TagSpecification]
poolTagSpecifications
          ),
        ByteString
"PubliclyAdvertisable" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
publiclyAdvertisable,
        ByteString
"Cidr" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
cidr
      ]

-- | /See:/ 'newProvisionByoipCidrResponse' smart constructor.
data ProvisionByoipCidrResponse = ProvisionByoipCidrResponse'
  { -- | Information about the address range.
    ProvisionByoipCidrResponse -> Maybe ByoipCidr
byoipCidr :: Prelude.Maybe ByoipCidr,
    -- | The response's http status code.
    ProvisionByoipCidrResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ProvisionByoipCidrResponse -> ProvisionByoipCidrResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProvisionByoipCidrResponse -> ProvisionByoipCidrResponse -> Bool
$c/= :: ProvisionByoipCidrResponse -> ProvisionByoipCidrResponse -> Bool
== :: ProvisionByoipCidrResponse -> ProvisionByoipCidrResponse -> Bool
$c== :: ProvisionByoipCidrResponse -> ProvisionByoipCidrResponse -> Bool
Prelude.Eq, ReadPrec [ProvisionByoipCidrResponse]
ReadPrec ProvisionByoipCidrResponse
Int -> ReadS ProvisionByoipCidrResponse
ReadS [ProvisionByoipCidrResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ProvisionByoipCidrResponse]
$creadListPrec :: ReadPrec [ProvisionByoipCidrResponse]
readPrec :: ReadPrec ProvisionByoipCidrResponse
$creadPrec :: ReadPrec ProvisionByoipCidrResponse
readList :: ReadS [ProvisionByoipCidrResponse]
$creadList :: ReadS [ProvisionByoipCidrResponse]
readsPrec :: Int -> ReadS ProvisionByoipCidrResponse
$creadsPrec :: Int -> ReadS ProvisionByoipCidrResponse
Prelude.Read, Int -> ProvisionByoipCidrResponse -> ShowS
[ProvisionByoipCidrResponse] -> ShowS
ProvisionByoipCidrResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProvisionByoipCidrResponse] -> ShowS
$cshowList :: [ProvisionByoipCidrResponse] -> ShowS
show :: ProvisionByoipCidrResponse -> String
$cshow :: ProvisionByoipCidrResponse -> String
showsPrec :: Int -> ProvisionByoipCidrResponse -> ShowS
$cshowsPrec :: Int -> ProvisionByoipCidrResponse -> ShowS
Prelude.Show, forall x.
Rep ProvisionByoipCidrResponse x -> ProvisionByoipCidrResponse
forall x.
ProvisionByoipCidrResponse -> Rep ProvisionByoipCidrResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ProvisionByoipCidrResponse x -> ProvisionByoipCidrResponse
$cfrom :: forall x.
ProvisionByoipCidrResponse -> Rep ProvisionByoipCidrResponse x
Prelude.Generic)

-- |
-- Create a value of 'ProvisionByoipCidrResponse' 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:
--
-- 'byoipCidr', 'provisionByoipCidrResponse_byoipCidr' - Information about the address range.
--
-- 'httpStatus', 'provisionByoipCidrResponse_httpStatus' - The response's http status code.
newProvisionByoipCidrResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ProvisionByoipCidrResponse
newProvisionByoipCidrResponse :: Int -> ProvisionByoipCidrResponse
newProvisionByoipCidrResponse Int
pHttpStatus_ =
  ProvisionByoipCidrResponse'
    { $sel:byoipCidr:ProvisionByoipCidrResponse' :: Maybe ByoipCidr
byoipCidr =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ProvisionByoipCidrResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the address range.
provisionByoipCidrResponse_byoipCidr :: Lens.Lens' ProvisionByoipCidrResponse (Prelude.Maybe ByoipCidr)
provisionByoipCidrResponse_byoipCidr :: Lens' ProvisionByoipCidrResponse (Maybe ByoipCidr)
provisionByoipCidrResponse_byoipCidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ProvisionByoipCidrResponse' {Maybe ByoipCidr
byoipCidr :: Maybe ByoipCidr
$sel:byoipCidr:ProvisionByoipCidrResponse' :: ProvisionByoipCidrResponse -> Maybe ByoipCidr
byoipCidr} -> Maybe ByoipCidr
byoipCidr) (\s :: ProvisionByoipCidrResponse
s@ProvisionByoipCidrResponse' {} Maybe ByoipCidr
a -> ProvisionByoipCidrResponse
s {$sel:byoipCidr:ProvisionByoipCidrResponse' :: Maybe ByoipCidr
byoipCidr = Maybe ByoipCidr
a} :: ProvisionByoipCidrResponse)

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

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