{-# 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.AssignPrivateIpAddresses
-- 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 secondary private IP addresses to the specified
-- network interface.
--
-- You can specify one or more specific secondary IP addresses, or you can
-- specify the number of secondary IP addresses to be automatically
-- assigned within the subnet\'s CIDR block range. The number of secondary
-- IP addresses that you can assign to an instance varies by instance type.
-- For information about instance types, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html Instance Types>
-- in the /Amazon Elastic Compute Cloud User Guide/. For more information
-- about Elastic IP addresses, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html Elastic IP Addresses>
-- in the /Amazon Elastic Compute Cloud User Guide/.
--
-- When you move a secondary private IP address to another network
-- interface, any Elastic IP address that is associated with the IP address
-- is also moved.
--
-- Remapping an IP address is an asynchronous operation. When you move an
-- IP address from one network interface to another, check
-- @network\/interfaces\/macs\/mac\/local-ipv4s@ in the instance metadata
-- to confirm that the remapping is complete.
--
-- You must specify either the IP addresses or the IP address count in the
-- request.
--
-- You can optionally use Prefix Delegation on the network interface. You
-- must specify either the IPv4 Prefix Delegation prefixes, or the IPv4
-- 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.AssignPrivateIpAddresses
  ( -- * Creating a Request
    AssignPrivateIpAddresses (..),
    newAssignPrivateIpAddresses,

    -- * Request Lenses
    assignPrivateIpAddresses_allowReassignment,
    assignPrivateIpAddresses_ipv4PrefixCount,
    assignPrivateIpAddresses_ipv4Prefixes,
    assignPrivateIpAddresses_privateIpAddresses,
    assignPrivateIpAddresses_secondaryPrivateIpAddressCount,
    assignPrivateIpAddresses_networkInterfaceId,

    -- * Destructuring the Response
    AssignPrivateIpAddressesResponse (..),
    newAssignPrivateIpAddressesResponse,

    -- * Response Lenses
    assignPrivateIpAddressesResponse_assignedIpv4Prefixes,
    assignPrivateIpAddressesResponse_assignedPrivateIpAddresses,
    assignPrivateIpAddressesResponse_networkInterfaceId,
    assignPrivateIpAddressesResponse_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

-- | Contains the parameters for AssignPrivateIpAddresses.
--
-- /See:/ 'newAssignPrivateIpAddresses' smart constructor.
data AssignPrivateIpAddresses = AssignPrivateIpAddresses'
  { -- | Indicates whether to allow an IP address that is already assigned to
    -- another network interface or instance to be reassigned to the specified
    -- network interface.
    AssignPrivateIpAddresses -> Maybe Bool
allowReassignment :: Prelude.Maybe Prelude.Bool,
    -- | The number of IPv4 prefixes that Amazon Web Services automatically
    -- assigns to the network interface. You cannot use this option if you use
    -- the @Ipv4 Prefixes@ option.
    AssignPrivateIpAddresses -> Maybe Int
ipv4PrefixCount :: Prelude.Maybe Prelude.Int,
    -- | One or more IPv4 prefixes assigned to the network interface. You cannot
    -- use this option if you use the @Ipv4PrefixCount@ option.
    AssignPrivateIpAddresses -> Maybe [Text]
ipv4Prefixes :: Prelude.Maybe [Prelude.Text],
    -- | The IP addresses to be assigned as a secondary private IP address to the
    -- network interface. You can\'t specify this parameter when also
    -- specifying a number of secondary IP addresses.
    --
    -- If you don\'t specify an IP address, Amazon EC2 automatically selects an
    -- IP address within the subnet range.
    AssignPrivateIpAddresses -> Maybe [Text]
privateIpAddresses :: Prelude.Maybe [Prelude.Text],
    -- | The number of secondary IP addresses to assign to the network interface.
    -- You can\'t specify this parameter when also specifying private IP
    -- addresses.
    AssignPrivateIpAddresses -> Maybe Int
secondaryPrivateIpAddressCount :: Prelude.Maybe Prelude.Int,
    -- | The ID of the network interface.
    AssignPrivateIpAddresses -> Text
networkInterfaceId :: Prelude.Text
  }
  deriving (AssignPrivateIpAddresses -> AssignPrivateIpAddresses -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignPrivateIpAddresses -> AssignPrivateIpAddresses -> Bool
$c/= :: AssignPrivateIpAddresses -> AssignPrivateIpAddresses -> Bool
== :: AssignPrivateIpAddresses -> AssignPrivateIpAddresses -> Bool
$c== :: AssignPrivateIpAddresses -> AssignPrivateIpAddresses -> Bool
Prelude.Eq, ReadPrec [AssignPrivateIpAddresses]
ReadPrec AssignPrivateIpAddresses
Int -> ReadS AssignPrivateIpAddresses
ReadS [AssignPrivateIpAddresses]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssignPrivateIpAddresses]
$creadListPrec :: ReadPrec [AssignPrivateIpAddresses]
readPrec :: ReadPrec AssignPrivateIpAddresses
$creadPrec :: ReadPrec AssignPrivateIpAddresses
readList :: ReadS [AssignPrivateIpAddresses]
$creadList :: ReadS [AssignPrivateIpAddresses]
readsPrec :: Int -> ReadS AssignPrivateIpAddresses
$creadsPrec :: Int -> ReadS AssignPrivateIpAddresses
Prelude.Read, Int -> AssignPrivateIpAddresses -> ShowS
[AssignPrivateIpAddresses] -> ShowS
AssignPrivateIpAddresses -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignPrivateIpAddresses] -> ShowS
$cshowList :: [AssignPrivateIpAddresses] -> ShowS
show :: AssignPrivateIpAddresses -> String
$cshow :: AssignPrivateIpAddresses -> String
showsPrec :: Int -> AssignPrivateIpAddresses -> ShowS
$cshowsPrec :: Int -> AssignPrivateIpAddresses -> ShowS
Prelude.Show, forall x.
Rep AssignPrivateIpAddresses x -> AssignPrivateIpAddresses
forall x.
AssignPrivateIpAddresses -> Rep AssignPrivateIpAddresses x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AssignPrivateIpAddresses x -> AssignPrivateIpAddresses
$cfrom :: forall x.
AssignPrivateIpAddresses -> Rep AssignPrivateIpAddresses x
Prelude.Generic)

-- |
-- Create a value of 'AssignPrivateIpAddresses' 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:
--
-- 'allowReassignment', 'assignPrivateIpAddresses_allowReassignment' - Indicates whether to allow an IP address that is already assigned to
-- another network interface or instance to be reassigned to the specified
-- network interface.
--
-- 'ipv4PrefixCount', 'assignPrivateIpAddresses_ipv4PrefixCount' - The number of IPv4 prefixes that Amazon Web Services automatically
-- assigns to the network interface. You cannot use this option if you use
-- the @Ipv4 Prefixes@ option.
--
-- 'ipv4Prefixes', 'assignPrivateIpAddresses_ipv4Prefixes' - One or more IPv4 prefixes assigned to the network interface. You cannot
-- use this option if you use the @Ipv4PrefixCount@ option.
--
-- 'privateIpAddresses', 'assignPrivateIpAddresses_privateIpAddresses' - The IP addresses to be assigned as a secondary private IP address to the
-- network interface. You can\'t specify this parameter when also
-- specifying a number of secondary IP addresses.
--
-- If you don\'t specify an IP address, Amazon EC2 automatically selects an
-- IP address within the subnet range.
--
-- 'secondaryPrivateIpAddressCount', 'assignPrivateIpAddresses_secondaryPrivateIpAddressCount' - The number of secondary IP addresses to assign to the network interface.
-- You can\'t specify this parameter when also specifying private IP
-- addresses.
--
-- 'networkInterfaceId', 'assignPrivateIpAddresses_networkInterfaceId' - The ID of the network interface.
newAssignPrivateIpAddresses ::
  -- | 'networkInterfaceId'
  Prelude.Text ->
  AssignPrivateIpAddresses
newAssignPrivateIpAddresses :: Text -> AssignPrivateIpAddresses
newAssignPrivateIpAddresses Text
pNetworkInterfaceId_ =
  AssignPrivateIpAddresses'
    { $sel:allowReassignment:AssignPrivateIpAddresses' :: Maybe Bool
allowReassignment =
        forall a. Maybe a
Prelude.Nothing,
      $sel:ipv4PrefixCount:AssignPrivateIpAddresses' :: Maybe Int
ipv4PrefixCount = forall a. Maybe a
Prelude.Nothing,
      $sel:ipv4Prefixes:AssignPrivateIpAddresses' :: Maybe [Text]
ipv4Prefixes = forall a. Maybe a
Prelude.Nothing,
      $sel:privateIpAddresses:AssignPrivateIpAddresses' :: Maybe [Text]
privateIpAddresses = forall a. Maybe a
Prelude.Nothing,
      $sel:secondaryPrivateIpAddressCount:AssignPrivateIpAddresses' :: Maybe Int
secondaryPrivateIpAddressCount = forall a. Maybe a
Prelude.Nothing,
      $sel:networkInterfaceId:AssignPrivateIpAddresses' :: Text
networkInterfaceId = Text
pNetworkInterfaceId_
    }

-- | Indicates whether to allow an IP address that is already assigned to
-- another network interface or instance to be reassigned to the specified
-- network interface.
assignPrivateIpAddresses_allowReassignment :: Lens.Lens' AssignPrivateIpAddresses (Prelude.Maybe Prelude.Bool)
assignPrivateIpAddresses_allowReassignment :: Lens' AssignPrivateIpAddresses (Maybe Bool)
assignPrivateIpAddresses_allowReassignment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddresses' {Maybe Bool
allowReassignment :: Maybe Bool
$sel:allowReassignment:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Bool
allowReassignment} -> Maybe Bool
allowReassignment) (\s :: AssignPrivateIpAddresses
s@AssignPrivateIpAddresses' {} Maybe Bool
a -> AssignPrivateIpAddresses
s {$sel:allowReassignment:AssignPrivateIpAddresses' :: Maybe Bool
allowReassignment = Maybe Bool
a} :: AssignPrivateIpAddresses)

-- | The number of IPv4 prefixes that Amazon Web Services automatically
-- assigns to the network interface. You cannot use this option if you use
-- the @Ipv4 Prefixes@ option.
assignPrivateIpAddresses_ipv4PrefixCount :: Lens.Lens' AssignPrivateIpAddresses (Prelude.Maybe Prelude.Int)
assignPrivateIpAddresses_ipv4PrefixCount :: Lens' AssignPrivateIpAddresses (Maybe Int)
assignPrivateIpAddresses_ipv4PrefixCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddresses' {Maybe Int
ipv4PrefixCount :: Maybe Int
$sel:ipv4PrefixCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
ipv4PrefixCount} -> Maybe Int
ipv4PrefixCount) (\s :: AssignPrivateIpAddresses
s@AssignPrivateIpAddresses' {} Maybe Int
a -> AssignPrivateIpAddresses
s {$sel:ipv4PrefixCount:AssignPrivateIpAddresses' :: Maybe Int
ipv4PrefixCount = Maybe Int
a} :: AssignPrivateIpAddresses)

-- | One or more IPv4 prefixes assigned to the network interface. You cannot
-- use this option if you use the @Ipv4PrefixCount@ option.
assignPrivateIpAddresses_ipv4Prefixes :: Lens.Lens' AssignPrivateIpAddresses (Prelude.Maybe [Prelude.Text])
assignPrivateIpAddresses_ipv4Prefixes :: Lens' AssignPrivateIpAddresses (Maybe [Text])
assignPrivateIpAddresses_ipv4Prefixes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddresses' {Maybe [Text]
ipv4Prefixes :: Maybe [Text]
$sel:ipv4Prefixes:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
ipv4Prefixes} -> Maybe [Text]
ipv4Prefixes) (\s :: AssignPrivateIpAddresses
s@AssignPrivateIpAddresses' {} Maybe [Text]
a -> AssignPrivateIpAddresses
s {$sel:ipv4Prefixes:AssignPrivateIpAddresses' :: Maybe [Text]
ipv4Prefixes = Maybe [Text]
a} :: AssignPrivateIpAddresses) 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 IP addresses to be assigned as a secondary private IP address to the
-- network interface. You can\'t specify this parameter when also
-- specifying a number of secondary IP addresses.
--
-- If you don\'t specify an IP address, Amazon EC2 automatically selects an
-- IP address within the subnet range.
assignPrivateIpAddresses_privateIpAddresses :: Lens.Lens' AssignPrivateIpAddresses (Prelude.Maybe [Prelude.Text])
assignPrivateIpAddresses_privateIpAddresses :: Lens' AssignPrivateIpAddresses (Maybe [Text])
assignPrivateIpAddresses_privateIpAddresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddresses' {Maybe [Text]
privateIpAddresses :: Maybe [Text]
$sel:privateIpAddresses:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
privateIpAddresses} -> Maybe [Text]
privateIpAddresses) (\s :: AssignPrivateIpAddresses
s@AssignPrivateIpAddresses' {} Maybe [Text]
a -> AssignPrivateIpAddresses
s {$sel:privateIpAddresses:AssignPrivateIpAddresses' :: Maybe [Text]
privateIpAddresses = Maybe [Text]
a} :: AssignPrivateIpAddresses) 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 secondary IP addresses to assign to the network interface.
-- You can\'t specify this parameter when also specifying private IP
-- addresses.
assignPrivateIpAddresses_secondaryPrivateIpAddressCount :: Lens.Lens' AssignPrivateIpAddresses (Prelude.Maybe Prelude.Int)
assignPrivateIpAddresses_secondaryPrivateIpAddressCount :: Lens' AssignPrivateIpAddresses (Maybe Int)
assignPrivateIpAddresses_secondaryPrivateIpAddressCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddresses' {Maybe Int
secondaryPrivateIpAddressCount :: Maybe Int
$sel:secondaryPrivateIpAddressCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
secondaryPrivateIpAddressCount} -> Maybe Int
secondaryPrivateIpAddressCount) (\s :: AssignPrivateIpAddresses
s@AssignPrivateIpAddresses' {} Maybe Int
a -> AssignPrivateIpAddresses
s {$sel:secondaryPrivateIpAddressCount:AssignPrivateIpAddresses' :: Maybe Int
secondaryPrivateIpAddressCount = Maybe Int
a} :: AssignPrivateIpAddresses)

-- | The ID of the network interface.
assignPrivateIpAddresses_networkInterfaceId :: Lens.Lens' AssignPrivateIpAddresses Prelude.Text
assignPrivateIpAddresses_networkInterfaceId :: Lens' AssignPrivateIpAddresses Text
assignPrivateIpAddresses_networkInterfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddresses' {Text
networkInterfaceId :: Text
$sel:networkInterfaceId:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Text
networkInterfaceId} -> Text
networkInterfaceId) (\s :: AssignPrivateIpAddresses
s@AssignPrivateIpAddresses' {} Text
a -> AssignPrivateIpAddresses
s {$sel:networkInterfaceId:AssignPrivateIpAddresses' :: Text
networkInterfaceId = Text
a} :: AssignPrivateIpAddresses)

instance Core.AWSRequest AssignPrivateIpAddresses where
  type
    AWSResponse AssignPrivateIpAddresses =
      AssignPrivateIpAddressesResponse
  request :: (Service -> Service)
-> AssignPrivateIpAddresses -> Request AssignPrivateIpAddresses
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 AssignPrivateIpAddresses
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AssignPrivateIpAddresses)))
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 [Ipv4PrefixSpecification]
-> Maybe [AssignedPrivateIpAddress]
-> Maybe Text
-> Int
-> AssignPrivateIpAddressesResponse
AssignPrivateIpAddressesResponse'
            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
"assignedIpv4PrefixSet"
                            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
"assignedPrivateIpAddressesSet"
                            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 AssignPrivateIpAddresses where
  hashWithSalt :: Int -> AssignPrivateIpAddresses -> Int
hashWithSalt Int
_salt AssignPrivateIpAddresses' {Maybe Bool
Maybe Int
Maybe [Text]
Text
networkInterfaceId :: Text
secondaryPrivateIpAddressCount :: Maybe Int
privateIpAddresses :: Maybe [Text]
ipv4Prefixes :: Maybe [Text]
ipv4PrefixCount :: Maybe Int
allowReassignment :: Maybe Bool
$sel:networkInterfaceId:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Text
$sel:secondaryPrivateIpAddressCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
$sel:privateIpAddresses:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
$sel:ipv4Prefixes:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
$sel:ipv4PrefixCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
$sel:allowReassignment:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
allowReassignment
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
ipv4PrefixCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
ipv4Prefixes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
privateIpAddresses
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
secondaryPrivateIpAddressCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
networkInterfaceId

instance Prelude.NFData AssignPrivateIpAddresses where
  rnf :: AssignPrivateIpAddresses -> ()
rnf AssignPrivateIpAddresses' {Maybe Bool
Maybe Int
Maybe [Text]
Text
networkInterfaceId :: Text
secondaryPrivateIpAddressCount :: Maybe Int
privateIpAddresses :: Maybe [Text]
ipv4Prefixes :: Maybe [Text]
ipv4PrefixCount :: Maybe Int
allowReassignment :: Maybe Bool
$sel:networkInterfaceId:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Text
$sel:secondaryPrivateIpAddressCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
$sel:privateIpAddresses:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
$sel:ipv4Prefixes:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
$sel:ipv4PrefixCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
$sel:allowReassignment:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
allowReassignment
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
ipv4PrefixCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
ipv4Prefixes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
privateIpAddresses
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
secondaryPrivateIpAddressCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
networkInterfaceId

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

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

instance Data.ToQuery AssignPrivateIpAddresses where
  toQuery :: AssignPrivateIpAddresses -> QueryString
toQuery AssignPrivateIpAddresses' {Maybe Bool
Maybe Int
Maybe [Text]
Text
networkInterfaceId :: Text
secondaryPrivateIpAddressCount :: Maybe Int
privateIpAddresses :: Maybe [Text]
ipv4Prefixes :: Maybe [Text]
ipv4PrefixCount :: Maybe Int
allowReassignment :: Maybe Bool
$sel:networkInterfaceId:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Text
$sel:secondaryPrivateIpAddressCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
$sel:privateIpAddresses:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
$sel:ipv4Prefixes:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe [Text]
$sel:ipv4PrefixCount:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Int
$sel:allowReassignment:AssignPrivateIpAddresses' :: AssignPrivateIpAddresses -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"AssignPrivateIpAddresses" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"AllowReassignment" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
allowReassignment,
        ByteString
"Ipv4PrefixCount" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
ipv4PrefixCount,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"Ipv4Prefix"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
ipv4Prefixes
          ),
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"PrivateIpAddress"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
privateIpAddresses
          ),
        ByteString
"SecondaryPrivateIpAddressCount"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
secondaryPrivateIpAddressCount,
        ByteString
"NetworkInterfaceId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
networkInterfaceId
      ]

-- | /See:/ 'newAssignPrivateIpAddressesResponse' smart constructor.
data AssignPrivateIpAddressesResponse = AssignPrivateIpAddressesResponse'
  { -- | The IPv4 prefixes that are assigned to the network interface.
    AssignPrivateIpAddressesResponse -> Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes :: Prelude.Maybe [Ipv4PrefixSpecification],
    -- | The private IP addresses assigned to the network interface.
    AssignPrivateIpAddressesResponse
-> Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses :: Prelude.Maybe [AssignedPrivateIpAddress],
    -- | The ID of the network interface.
    AssignPrivateIpAddressesResponse -> Maybe Text
networkInterfaceId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    AssignPrivateIpAddressesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (AssignPrivateIpAddressesResponse
-> AssignPrivateIpAddressesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignPrivateIpAddressesResponse
-> AssignPrivateIpAddressesResponse -> Bool
$c/= :: AssignPrivateIpAddressesResponse
-> AssignPrivateIpAddressesResponse -> Bool
== :: AssignPrivateIpAddressesResponse
-> AssignPrivateIpAddressesResponse -> Bool
$c== :: AssignPrivateIpAddressesResponse
-> AssignPrivateIpAddressesResponse -> Bool
Prelude.Eq, ReadPrec [AssignPrivateIpAddressesResponse]
ReadPrec AssignPrivateIpAddressesResponse
Int -> ReadS AssignPrivateIpAddressesResponse
ReadS [AssignPrivateIpAddressesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssignPrivateIpAddressesResponse]
$creadListPrec :: ReadPrec [AssignPrivateIpAddressesResponse]
readPrec :: ReadPrec AssignPrivateIpAddressesResponse
$creadPrec :: ReadPrec AssignPrivateIpAddressesResponse
readList :: ReadS [AssignPrivateIpAddressesResponse]
$creadList :: ReadS [AssignPrivateIpAddressesResponse]
readsPrec :: Int -> ReadS AssignPrivateIpAddressesResponse
$creadsPrec :: Int -> ReadS AssignPrivateIpAddressesResponse
Prelude.Read, Int -> AssignPrivateIpAddressesResponse -> ShowS
[AssignPrivateIpAddressesResponse] -> ShowS
AssignPrivateIpAddressesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignPrivateIpAddressesResponse] -> ShowS
$cshowList :: [AssignPrivateIpAddressesResponse] -> ShowS
show :: AssignPrivateIpAddressesResponse -> String
$cshow :: AssignPrivateIpAddressesResponse -> String
showsPrec :: Int -> AssignPrivateIpAddressesResponse -> ShowS
$cshowsPrec :: Int -> AssignPrivateIpAddressesResponse -> ShowS
Prelude.Show, forall x.
Rep AssignPrivateIpAddressesResponse x
-> AssignPrivateIpAddressesResponse
forall x.
AssignPrivateIpAddressesResponse
-> Rep AssignPrivateIpAddressesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AssignPrivateIpAddressesResponse x
-> AssignPrivateIpAddressesResponse
$cfrom :: forall x.
AssignPrivateIpAddressesResponse
-> Rep AssignPrivateIpAddressesResponse x
Prelude.Generic)

-- |
-- Create a value of 'AssignPrivateIpAddressesResponse' 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:
--
-- 'assignedIpv4Prefixes', 'assignPrivateIpAddressesResponse_assignedIpv4Prefixes' - The IPv4 prefixes that are assigned to the network interface.
--
-- 'assignedPrivateIpAddresses', 'assignPrivateIpAddressesResponse_assignedPrivateIpAddresses' - The private IP addresses assigned to the network interface.
--
-- 'networkInterfaceId', 'assignPrivateIpAddressesResponse_networkInterfaceId' - The ID of the network interface.
--
-- 'httpStatus', 'assignPrivateIpAddressesResponse_httpStatus' - The response's http status code.
newAssignPrivateIpAddressesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  AssignPrivateIpAddressesResponse
newAssignPrivateIpAddressesResponse :: Int -> AssignPrivateIpAddressesResponse
newAssignPrivateIpAddressesResponse Int
pHttpStatus_ =
  AssignPrivateIpAddressesResponse'
    { $sel:assignedIpv4Prefixes:AssignPrivateIpAddressesResponse' :: Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes =
        forall a. Maybe a
Prelude.Nothing,
      $sel:assignedPrivateIpAddresses:AssignPrivateIpAddressesResponse' :: Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses =
        forall a. Maybe a
Prelude.Nothing,
      $sel:networkInterfaceId:AssignPrivateIpAddressesResponse' :: Maybe Text
networkInterfaceId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:AssignPrivateIpAddressesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The IPv4 prefixes that are assigned to the network interface.
assignPrivateIpAddressesResponse_assignedIpv4Prefixes :: Lens.Lens' AssignPrivateIpAddressesResponse (Prelude.Maybe [Ipv4PrefixSpecification])
assignPrivateIpAddressesResponse_assignedIpv4Prefixes :: Lens'
  AssignPrivateIpAddressesResponse (Maybe [Ipv4PrefixSpecification])
assignPrivateIpAddressesResponse_assignedIpv4Prefixes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddressesResponse' {Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes :: Maybe [Ipv4PrefixSpecification]
$sel:assignedIpv4Prefixes:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse -> Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes} -> Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes) (\s :: AssignPrivateIpAddressesResponse
s@AssignPrivateIpAddressesResponse' {} Maybe [Ipv4PrefixSpecification]
a -> AssignPrivateIpAddressesResponse
s {$sel:assignedIpv4Prefixes:AssignPrivateIpAddressesResponse' :: Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes = Maybe [Ipv4PrefixSpecification]
a} :: AssignPrivateIpAddressesResponse) 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 private IP addresses assigned to the network interface.
assignPrivateIpAddressesResponse_assignedPrivateIpAddresses :: Lens.Lens' AssignPrivateIpAddressesResponse (Prelude.Maybe [AssignedPrivateIpAddress])
assignPrivateIpAddressesResponse_assignedPrivateIpAddresses :: Lens'
  AssignPrivateIpAddressesResponse (Maybe [AssignedPrivateIpAddress])
assignPrivateIpAddressesResponse_assignedPrivateIpAddresses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddressesResponse' {Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses :: Maybe [AssignedPrivateIpAddress]
$sel:assignedPrivateIpAddresses:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse
-> Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses} -> Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses) (\s :: AssignPrivateIpAddressesResponse
s@AssignPrivateIpAddressesResponse' {} Maybe [AssignedPrivateIpAddress]
a -> AssignPrivateIpAddressesResponse
s {$sel:assignedPrivateIpAddresses:AssignPrivateIpAddressesResponse' :: Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses = Maybe [AssignedPrivateIpAddress]
a} :: AssignPrivateIpAddressesResponse) 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.
assignPrivateIpAddressesResponse_networkInterfaceId :: Lens.Lens' AssignPrivateIpAddressesResponse (Prelude.Maybe Prelude.Text)
assignPrivateIpAddressesResponse_networkInterfaceId :: Lens' AssignPrivateIpAddressesResponse (Maybe Text)
assignPrivateIpAddressesResponse_networkInterfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssignPrivateIpAddressesResponse' {Maybe Text
networkInterfaceId :: Maybe Text
$sel:networkInterfaceId:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse -> Maybe Text
networkInterfaceId} -> Maybe Text
networkInterfaceId) (\s :: AssignPrivateIpAddressesResponse
s@AssignPrivateIpAddressesResponse' {} Maybe Text
a -> AssignPrivateIpAddressesResponse
s {$sel:networkInterfaceId:AssignPrivateIpAddressesResponse' :: Maybe Text
networkInterfaceId = Maybe Text
a} :: AssignPrivateIpAddressesResponse)

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

instance
  Prelude.NFData
    AssignPrivateIpAddressesResponse
  where
  rnf :: AssignPrivateIpAddressesResponse -> ()
rnf AssignPrivateIpAddressesResponse' {Int
Maybe [AssignedPrivateIpAddress]
Maybe [Ipv4PrefixSpecification]
Maybe Text
httpStatus :: Int
networkInterfaceId :: Maybe Text
assignedPrivateIpAddresses :: Maybe [AssignedPrivateIpAddress]
assignedIpv4Prefixes :: Maybe [Ipv4PrefixSpecification]
$sel:httpStatus:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse -> Int
$sel:networkInterfaceId:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse -> Maybe Text
$sel:assignedPrivateIpAddresses:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse
-> Maybe [AssignedPrivateIpAddress]
$sel:assignedIpv4Prefixes:AssignPrivateIpAddressesResponse' :: AssignPrivateIpAddressesResponse -> Maybe [Ipv4PrefixSpecification]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Ipv4PrefixSpecification]
assignedIpv4Prefixes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [AssignedPrivateIpAddress]
assignedPrivateIpAddresses
      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