{-# 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.AssignIpv6Addresses
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Assigns one or more IPv6 addresses to the specified network interface.
-- You can specify one or more specific IPv6 addresses, or you can specify
-- the number of IPv6 addresses to be automatically assigned from within
-- the subnet\'s IPv6 CIDR block range. You can assign as many IPv6
-- addresses to a network interface as you can assign private IPv4
-- addresses, and the limit varies per instance type. For information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI IP Addresses Per Network Interface Per Instance Type>
-- in the /Amazon Elastic Compute Cloud User Guide/.
--
-- You must specify either the IPv6 addresses or the IPv6 address count in
-- the request.
--
-- You can optionally use Prefix Delegation on the network interface. You
-- must specify either the IPV6 Prefix Delegation prefixes, or the IPv6
-- Prefix Delegation count. For information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html Assigning prefixes to Amazon EC2 network interfaces>
-- in the /Amazon Elastic Compute Cloud User Guide/.
module Amazonka.EC2.AssignIpv6Addresses
  ( -- * Creating a Request
    AssignIpv6Addresses (..),
    newAssignIpv6Addresses,

    -- * Request Lenses
    assignIpv6Addresses_ipv6AddressCount,
    assignIpv6Addresses_ipv6Addresses,
    assignIpv6Addresses_ipv6PrefixCount,
    assignIpv6Addresses_ipv6Prefixes,
    assignIpv6Addresses_networkInterfaceId,

    -- * Destructuring the Response
    AssignIpv6AddressesResponse (..),
    newAssignIpv6AddressesResponse,

    -- * Response Lenses
    assignIpv6AddressesResponse_assignedIpv6Addresses,
    assignIpv6AddressesResponse_assignedIpv6Prefixes,
    assignIpv6AddressesResponse_networkInterfaceId,
    assignIpv6AddressesResponse_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:/ 'newAssignIpv6Addresses' smart constructor.
data AssignIpv6Addresses = AssignIpv6Addresses'
  { -- | The number of additional IPv6 addresses to assign to the network
    -- interface. The specified number of IPv6 addresses are assigned in
    -- addition to the existing IPv6 addresses that are already assigned to the
    -- network interface. Amazon EC2 automatically selects the IPv6 addresses
    -- from the subnet range. You can\'t use this option if specifying specific
    -- IPv6 addresses.
    AssignIpv6Addresses -> Maybe Int
ipv6AddressCount :: Prelude.Maybe Prelude.Int,
    -- | The IPv6 addresses to be assigned to the network interface. You can\'t
    -- use this option if you\'re specifying a number of IPv6 addresses.
    AssignIpv6Addresses -> Maybe [Text]
ipv6Addresses :: Prelude.Maybe [Prelude.Text],
    -- | The number of IPv6 prefixes that Amazon Web Services automatically
    -- assigns to the network interface. You cannot use this option if you use
    -- the @Ipv6Prefixes@ option.
    AssignIpv6Addresses -> Maybe Int
ipv6PrefixCount :: Prelude.Maybe Prelude.Int,
    -- | One or more IPv6 prefixes assigned to the network interface. You cannot
    -- use this option if you use the @Ipv6PrefixCount@ option.
    AssignIpv6Addresses -> Maybe [Text]
ipv6Prefixes :: Prelude.Maybe [Prelude.Text],
    -- | The ID of the network interface.
    AssignIpv6Addresses -> Text
networkInterfaceId :: Prelude.Text
  }
  deriving (AssignIpv6Addresses -> AssignIpv6Addresses -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignIpv6Addresses -> AssignIpv6Addresses -> Bool
$c/= :: AssignIpv6Addresses -> AssignIpv6Addresses -> Bool
== :: AssignIpv6Addresses -> AssignIpv6Addresses -> Bool
$c== :: AssignIpv6Addresses -> AssignIpv6Addresses -> Bool
Prelude.Eq, ReadPrec [AssignIpv6Addresses]
ReadPrec AssignIpv6Addresses
Int -> ReadS AssignIpv6Addresses
ReadS [AssignIpv6Addresses]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssignIpv6Addresses]
$creadListPrec :: ReadPrec [AssignIpv6Addresses]
readPrec :: ReadPrec AssignIpv6Addresses
$creadPrec :: ReadPrec AssignIpv6Addresses
readList :: ReadS [AssignIpv6Addresses]
$creadList :: ReadS [AssignIpv6Addresses]
readsPrec :: Int -> ReadS AssignIpv6Addresses
$creadsPrec :: Int -> ReadS AssignIpv6Addresses
Prelude.Read, Int -> AssignIpv6Addresses -> ShowS
[AssignIpv6Addresses] -> ShowS
AssignIpv6Addresses -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignIpv6Addresses] -> ShowS
$cshowList :: [AssignIpv6Addresses] -> ShowS
show :: AssignIpv6Addresses -> String
$cshow :: AssignIpv6Addresses -> String
showsPrec :: Int -> AssignIpv6Addresses -> ShowS
$cshowsPrec :: Int -> AssignIpv6Addresses -> ShowS
Prelude.Show, forall x. Rep AssignIpv6Addresses x -> AssignIpv6Addresses
forall x. AssignIpv6Addresses -> Rep AssignIpv6Addresses x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AssignIpv6Addresses x -> AssignIpv6Addresses
$cfrom :: forall x. AssignIpv6Addresses -> Rep AssignIpv6Addresses x
Prelude.Generic)

-- |
-- Create a value of 'AssignIpv6Addresses' 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:
--
-- 'ipv6AddressCount', 'assignIpv6Addresses_ipv6AddressCount' - The number of additional IPv6 addresses to assign to the network
-- interface. The specified number of IPv6 addresses are assigned in
-- addition to the existing IPv6 addresses that are already assigned to the
-- network interface. Amazon EC2 automatically selects the IPv6 addresses
-- from the subnet range. You can\'t use this option if specifying specific
-- IPv6 addresses.
--
-- 'ipv6Addresses', 'assignIpv6Addresses_ipv6Addresses' - The IPv6 addresses to be assigned to the network interface. You can\'t
-- use this option if you\'re specifying a number of IPv6 addresses.
--
-- 'ipv6PrefixCount', 'assignIpv6Addresses_ipv6PrefixCount' - The number of IPv6 prefixes that Amazon Web Services automatically
-- assigns to the network interface. You cannot use this option if you use
-- the @Ipv6Prefixes@ option.
--
-- 'ipv6Prefixes', 'assignIpv6Addresses_ipv6Prefixes' - One or more IPv6 prefixes assigned to the network interface. You cannot
-- use this option if you use the @Ipv6PrefixCount@ option.
--
-- 'networkInterfaceId', 'assignIpv6Addresses_networkInterfaceId' - The ID of the network interface.
newAssignIpv6Addresses ::
  -- | 'networkInterfaceId'
  Prelude.Text ->
  AssignIpv6Addresses
newAssignIpv6Addresses :: Text -> AssignIpv6Addresses
newAssignIpv6Addresses Text
pNetworkInterfaceId_ =
  AssignIpv6Addresses'
    { $sel:ipv6AddressCount:AssignIpv6Addresses' :: Maybe Int
ipv6AddressCount =
        forall a. Maybe a
Prelude.Nothing,
      $sel:ipv6Addresses:AssignIpv6Addresses' :: Maybe [Text]
ipv6Addresses = forall a. Maybe a
Prelude.Nothing,
      $sel:ipv6PrefixCount:AssignIpv6Addresses' :: Maybe Int
ipv6PrefixCount = forall a. Maybe a
Prelude.Nothing,
      $sel:ipv6Prefixes:AssignIpv6Addresses' :: Maybe [Text]
ipv6Prefixes = forall a. Maybe a
Prelude.Nothing,
      $sel:networkInterfaceId:AssignIpv6Addresses' :: Text
networkInterfaceId = Text
pNetworkInterfaceId_
    }

-- | The number of additional IPv6 addresses to assign to the network
-- interface. The specified number of IPv6 addresses are assigned in
-- addition to the existing IPv6 addresses that are already assigned to the
-- network interface. Amazon EC2 automatically selects the IPv6 addresses
-- from the subnet range. You can\'t use this option if specifying specific
-- IPv6 addresses.
assignIpv6Addresses_ipv6AddressCount :: Lens.Lens' AssignIpv6Addresses (Prelude.Maybe Prelude.Int)
assignIpv6Addresses_ipv6AddressCount :: Lens' AssignIpv6Addresses (Maybe Int)
assignIpv6Addresses_ipv6AddressCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6Addresses' {Maybe Int
ipv6AddressCount :: Maybe Int
$sel:ipv6AddressCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
ipv6AddressCount} -> Maybe Int
ipv6AddressCount) (\s :: AssignIpv6Addresses
s@AssignIpv6Addresses' {} Maybe Int
a -> AssignIpv6Addresses
s {$sel:ipv6AddressCount:AssignIpv6Addresses' :: Maybe Int
ipv6AddressCount = Maybe Int
a} :: AssignIpv6Addresses)

-- | The IPv6 addresses to be assigned to the network interface. You can\'t
-- use this option if you\'re specifying a number of IPv6 addresses.
assignIpv6Addresses_ipv6Addresses :: Lens.Lens' AssignIpv6Addresses (Prelude.Maybe [Prelude.Text])
assignIpv6Addresses_ipv6Addresses :: Lens' AssignIpv6Addresses (Maybe [Text])
assignIpv6Addresses_ipv6Addresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6Addresses' {Maybe [Text]
ipv6Addresses :: Maybe [Text]
$sel:ipv6Addresses:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
ipv6Addresses} -> Maybe [Text]
ipv6Addresses) (\s :: AssignIpv6Addresses
s@AssignIpv6Addresses' {} Maybe [Text]
a -> AssignIpv6Addresses
s {$sel:ipv6Addresses:AssignIpv6Addresses' :: Maybe [Text]
ipv6Addresses = Maybe [Text]
a} :: AssignIpv6Addresses) 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 number of IPv6 prefixes that Amazon Web Services automatically
-- assigns to the network interface. You cannot use this option if you use
-- the @Ipv6Prefixes@ option.
assignIpv6Addresses_ipv6PrefixCount :: Lens.Lens' AssignIpv6Addresses (Prelude.Maybe Prelude.Int)
assignIpv6Addresses_ipv6PrefixCount :: Lens' AssignIpv6Addresses (Maybe Int)
assignIpv6Addresses_ipv6PrefixCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6Addresses' {Maybe Int
ipv6PrefixCount :: Maybe Int
$sel:ipv6PrefixCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
ipv6PrefixCount} -> Maybe Int
ipv6PrefixCount) (\s :: AssignIpv6Addresses
s@AssignIpv6Addresses' {} Maybe Int
a -> AssignIpv6Addresses
s {$sel:ipv6PrefixCount:AssignIpv6Addresses' :: Maybe Int
ipv6PrefixCount = Maybe Int
a} :: AssignIpv6Addresses)

-- | One or more IPv6 prefixes assigned to the network interface. You cannot
-- use this option if you use the @Ipv6PrefixCount@ option.
assignIpv6Addresses_ipv6Prefixes :: Lens.Lens' AssignIpv6Addresses (Prelude.Maybe [Prelude.Text])
assignIpv6Addresses_ipv6Prefixes :: Lens' AssignIpv6Addresses (Maybe [Text])
assignIpv6Addresses_ipv6Prefixes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6Addresses' {Maybe [Text]
ipv6Prefixes :: Maybe [Text]
$sel:ipv6Prefixes:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
ipv6Prefixes} -> Maybe [Text]
ipv6Prefixes) (\s :: AssignIpv6Addresses
s@AssignIpv6Addresses' {} Maybe [Text]
a -> AssignIpv6Addresses
s {$sel:ipv6Prefixes:AssignIpv6Addresses' :: Maybe [Text]
ipv6Prefixes = Maybe [Text]
a} :: AssignIpv6Addresses) 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 ID of the network interface.
assignIpv6Addresses_networkInterfaceId :: Lens.Lens' AssignIpv6Addresses Prelude.Text
assignIpv6Addresses_networkInterfaceId :: Lens' AssignIpv6Addresses Text
assignIpv6Addresses_networkInterfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6Addresses' {Text
networkInterfaceId :: Text
$sel:networkInterfaceId:AssignIpv6Addresses' :: AssignIpv6Addresses -> Text
networkInterfaceId} -> Text
networkInterfaceId) (\s :: AssignIpv6Addresses
s@AssignIpv6Addresses' {} Text
a -> AssignIpv6Addresses
s {$sel:networkInterfaceId:AssignIpv6Addresses' :: Text
networkInterfaceId = Text
a} :: AssignIpv6Addresses)

instance Core.AWSRequest AssignIpv6Addresses where
  type
    AWSResponse AssignIpv6Addresses =
      AssignIpv6AddressesResponse
  request :: (Service -> Service)
-> AssignIpv6Addresses -> Request AssignIpv6Addresses
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 AssignIpv6Addresses
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AssignIpv6Addresses)))
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 [Text]
-> Maybe [Text] -> Maybe Text -> Int -> AssignIpv6AddressesResponse
AssignIpv6AddressesResponse'
            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
"assignedIpv6Addresses"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"assignedIpv6PrefixSet"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"networkInterfaceId")
            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 AssignIpv6Addresses where
  hashWithSalt :: Int -> AssignIpv6Addresses -> Int
hashWithSalt Int
_salt AssignIpv6Addresses' {Maybe Int
Maybe [Text]
Text
networkInterfaceId :: Text
ipv6Prefixes :: Maybe [Text]
ipv6PrefixCount :: Maybe Int
ipv6Addresses :: Maybe [Text]
ipv6AddressCount :: Maybe Int
$sel:networkInterfaceId:AssignIpv6Addresses' :: AssignIpv6Addresses -> Text
$sel:ipv6Prefixes:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
$sel:ipv6PrefixCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
$sel:ipv6Addresses:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
$sel:ipv6AddressCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
ipv6AddressCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
ipv6Addresses
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
ipv6PrefixCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
ipv6Prefixes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
networkInterfaceId

instance Prelude.NFData AssignIpv6Addresses where
  rnf :: AssignIpv6Addresses -> ()
rnf AssignIpv6Addresses' {Maybe Int
Maybe [Text]
Text
networkInterfaceId :: Text
ipv6Prefixes :: Maybe [Text]
ipv6PrefixCount :: Maybe Int
ipv6Addresses :: Maybe [Text]
ipv6AddressCount :: Maybe Int
$sel:networkInterfaceId:AssignIpv6Addresses' :: AssignIpv6Addresses -> Text
$sel:ipv6Prefixes:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
$sel:ipv6PrefixCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
$sel:ipv6Addresses:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
$sel:ipv6AddressCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
ipv6AddressCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
ipv6Addresses
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
ipv6PrefixCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
ipv6Prefixes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
networkInterfaceId

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

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

instance Data.ToQuery AssignIpv6Addresses where
  toQuery :: AssignIpv6Addresses -> QueryString
toQuery AssignIpv6Addresses' {Maybe Int
Maybe [Text]
Text
networkInterfaceId :: Text
ipv6Prefixes :: Maybe [Text]
ipv6PrefixCount :: Maybe Int
ipv6Addresses :: Maybe [Text]
ipv6AddressCount :: Maybe Int
$sel:networkInterfaceId:AssignIpv6Addresses' :: AssignIpv6Addresses -> Text
$sel:ipv6Prefixes:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
$sel:ipv6PrefixCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
$sel:ipv6Addresses:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe [Text]
$sel:ipv6AddressCount:AssignIpv6Addresses' :: AssignIpv6Addresses -> Maybe Int
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"AssignIpv6Addresses" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"Ipv6AddressCount" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
ipv6AddressCount,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"Ipv6Addresses"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
ipv6Addresses
          ),
        ByteString
"Ipv6PrefixCount" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
ipv6PrefixCount,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"Ipv6Prefix"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
ipv6Prefixes
          ),
        ByteString
"NetworkInterfaceId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
networkInterfaceId
      ]

-- | /See:/ 'newAssignIpv6AddressesResponse' smart constructor.
data AssignIpv6AddressesResponse = AssignIpv6AddressesResponse'
  { -- | The new IPv6 addresses assigned to the network interface. Existing IPv6
    -- addresses that were assigned to the network interface before the request
    -- are not included.
    AssignIpv6AddressesResponse -> Maybe [Text]
assignedIpv6Addresses :: Prelude.Maybe [Prelude.Text],
    -- | The IPv6 prefixes that are assigned to the network interface.
    AssignIpv6AddressesResponse -> Maybe [Text]
assignedIpv6Prefixes :: Prelude.Maybe [Prelude.Text],
    -- | The ID of the network interface.
    AssignIpv6AddressesResponse -> Maybe Text
networkInterfaceId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    AssignIpv6AddressesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (AssignIpv6AddressesResponse -> AssignIpv6AddressesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignIpv6AddressesResponse -> AssignIpv6AddressesResponse -> Bool
$c/= :: AssignIpv6AddressesResponse -> AssignIpv6AddressesResponse -> Bool
== :: AssignIpv6AddressesResponse -> AssignIpv6AddressesResponse -> Bool
$c== :: AssignIpv6AddressesResponse -> AssignIpv6AddressesResponse -> Bool
Prelude.Eq, ReadPrec [AssignIpv6AddressesResponse]
ReadPrec AssignIpv6AddressesResponse
Int -> ReadS AssignIpv6AddressesResponse
ReadS [AssignIpv6AddressesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssignIpv6AddressesResponse]
$creadListPrec :: ReadPrec [AssignIpv6AddressesResponse]
readPrec :: ReadPrec AssignIpv6AddressesResponse
$creadPrec :: ReadPrec AssignIpv6AddressesResponse
readList :: ReadS [AssignIpv6AddressesResponse]
$creadList :: ReadS [AssignIpv6AddressesResponse]
readsPrec :: Int -> ReadS AssignIpv6AddressesResponse
$creadsPrec :: Int -> ReadS AssignIpv6AddressesResponse
Prelude.Read, Int -> AssignIpv6AddressesResponse -> ShowS
[AssignIpv6AddressesResponse] -> ShowS
AssignIpv6AddressesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignIpv6AddressesResponse] -> ShowS
$cshowList :: [AssignIpv6AddressesResponse] -> ShowS
show :: AssignIpv6AddressesResponse -> String
$cshow :: AssignIpv6AddressesResponse -> String
showsPrec :: Int -> AssignIpv6AddressesResponse -> ShowS
$cshowsPrec :: Int -> AssignIpv6AddressesResponse -> ShowS
Prelude.Show, forall x.
Rep AssignIpv6AddressesResponse x -> AssignIpv6AddressesResponse
forall x.
AssignIpv6AddressesResponse -> Rep AssignIpv6AddressesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AssignIpv6AddressesResponse x -> AssignIpv6AddressesResponse
$cfrom :: forall x.
AssignIpv6AddressesResponse -> Rep AssignIpv6AddressesResponse x
Prelude.Generic)

-- |
-- Create a value of 'AssignIpv6AddressesResponse' 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:
--
-- 'assignedIpv6Addresses', 'assignIpv6AddressesResponse_assignedIpv6Addresses' - The new IPv6 addresses assigned to the network interface. Existing IPv6
-- addresses that were assigned to the network interface before the request
-- are not included.
--
-- 'assignedIpv6Prefixes', 'assignIpv6AddressesResponse_assignedIpv6Prefixes' - The IPv6 prefixes that are assigned to the network interface.
--
-- 'networkInterfaceId', 'assignIpv6AddressesResponse_networkInterfaceId' - The ID of the network interface.
--
-- 'httpStatus', 'assignIpv6AddressesResponse_httpStatus' - The response's http status code.
newAssignIpv6AddressesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  AssignIpv6AddressesResponse
newAssignIpv6AddressesResponse :: Int -> AssignIpv6AddressesResponse
newAssignIpv6AddressesResponse Int
pHttpStatus_ =
  AssignIpv6AddressesResponse'
    { $sel:assignedIpv6Addresses:AssignIpv6AddressesResponse' :: Maybe [Text]
assignedIpv6Addresses =
        forall a. Maybe a
Prelude.Nothing,
      $sel:assignedIpv6Prefixes:AssignIpv6AddressesResponse' :: Maybe [Text]
assignedIpv6Prefixes = forall a. Maybe a
Prelude.Nothing,
      $sel:networkInterfaceId:AssignIpv6AddressesResponse' :: Maybe Text
networkInterfaceId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:AssignIpv6AddressesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The new IPv6 addresses assigned to the network interface. Existing IPv6
-- addresses that were assigned to the network interface before the request
-- are not included.
assignIpv6AddressesResponse_assignedIpv6Addresses :: Lens.Lens' AssignIpv6AddressesResponse (Prelude.Maybe [Prelude.Text])
assignIpv6AddressesResponse_assignedIpv6Addresses :: Lens' AssignIpv6AddressesResponse (Maybe [Text])
assignIpv6AddressesResponse_assignedIpv6Addresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6AddressesResponse' {Maybe [Text]
assignedIpv6Addresses :: Maybe [Text]
$sel:assignedIpv6Addresses:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Maybe [Text]
assignedIpv6Addresses} -> Maybe [Text]
assignedIpv6Addresses) (\s :: AssignIpv6AddressesResponse
s@AssignIpv6AddressesResponse' {} Maybe [Text]
a -> AssignIpv6AddressesResponse
s {$sel:assignedIpv6Addresses:AssignIpv6AddressesResponse' :: Maybe [Text]
assignedIpv6Addresses = Maybe [Text]
a} :: AssignIpv6AddressesResponse) 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 IPv6 prefixes that are assigned to the network interface.
assignIpv6AddressesResponse_assignedIpv6Prefixes :: Lens.Lens' AssignIpv6AddressesResponse (Prelude.Maybe [Prelude.Text])
assignIpv6AddressesResponse_assignedIpv6Prefixes :: Lens' AssignIpv6AddressesResponse (Maybe [Text])
assignIpv6AddressesResponse_assignedIpv6Prefixes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6AddressesResponse' {Maybe [Text]
assignedIpv6Prefixes :: Maybe [Text]
$sel:assignedIpv6Prefixes:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Maybe [Text]
assignedIpv6Prefixes} -> Maybe [Text]
assignedIpv6Prefixes) (\s :: AssignIpv6AddressesResponse
s@AssignIpv6AddressesResponse' {} Maybe [Text]
a -> AssignIpv6AddressesResponse
s {$sel:assignedIpv6Prefixes:AssignIpv6AddressesResponse' :: Maybe [Text]
assignedIpv6Prefixes = Maybe [Text]
a} :: AssignIpv6AddressesResponse) 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 ID of the network interface.
assignIpv6AddressesResponse_networkInterfaceId :: Lens.Lens' AssignIpv6AddressesResponse (Prelude.Maybe Prelude.Text)
assignIpv6AddressesResponse_networkInterfaceId :: Lens' AssignIpv6AddressesResponse (Maybe Text)
assignIpv6AddressesResponse_networkInterfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignIpv6AddressesResponse' {Maybe Text
networkInterfaceId :: Maybe Text
$sel:networkInterfaceId:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Maybe Text
networkInterfaceId} -> Maybe Text
networkInterfaceId) (\s :: AssignIpv6AddressesResponse
s@AssignIpv6AddressesResponse' {} Maybe Text
a -> AssignIpv6AddressesResponse
s {$sel:networkInterfaceId:AssignIpv6AddressesResponse' :: Maybe Text
networkInterfaceId = Maybe Text
a} :: AssignIpv6AddressesResponse)

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

instance Prelude.NFData AssignIpv6AddressesResponse where
  rnf :: AssignIpv6AddressesResponse -> ()
rnf AssignIpv6AddressesResponse' {Int
Maybe [Text]
Maybe Text
httpStatus :: Int
networkInterfaceId :: Maybe Text
assignedIpv6Prefixes :: Maybe [Text]
assignedIpv6Addresses :: Maybe [Text]
$sel:httpStatus:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Int
$sel:networkInterfaceId:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Maybe Text
$sel:assignedIpv6Prefixes:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Maybe [Text]
$sel:assignedIpv6Addresses:AssignIpv6AddressesResponse' :: AssignIpv6AddressesResponse -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
assignedIpv6Addresses
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
assignedIpv6Prefixes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
networkInterfaceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus