{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# 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.Types.Address
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.EC2.Types.Address where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.DomainType
import Amazonka.EC2.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes an Elastic IP address, or a carrier IP address.
--
-- /See:/ 'newAddress' smart constructor.
data Address = Address'
  { -- | The ID representing the allocation of the address for use with EC2-VPC.
    Address -> Maybe Text
allocationId :: Prelude.Maybe Prelude.Text,
    -- | The ID representing the association of the address with an instance in a
    -- VPC.
    Address -> Maybe Text
associationId :: Prelude.Maybe Prelude.Text,
    -- | The carrier IP address associated. This option is only available for
    -- network interfaces which reside in a subnet in a Wavelength Zone (for
    -- example an EC2 instance).
    Address -> Maybe Text
carrierIp :: Prelude.Maybe Prelude.Text,
    -- | The customer-owned IP address.
    Address -> Maybe Text
customerOwnedIp :: Prelude.Maybe Prelude.Text,
    -- | The ID of the customer-owned address pool.
    Address -> Maybe Text
customerOwnedIpv4Pool :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether this Elastic IP address is for use with instances in
    -- EC2-Classic (@standard@) or instances in a VPC (@vpc@).
    Address -> Maybe DomainType
domain :: Prelude.Maybe DomainType,
    -- | The ID of the instance that the address is associated with (if any).
    Address -> Maybe Text
instanceId :: Prelude.Maybe Prelude.Text,
    -- | The name of the unique set of Availability Zones, Local Zones, or
    -- Wavelength Zones from which Amazon Web Services advertises IP addresses.
    Address -> Maybe Text
networkBorderGroup :: Prelude.Maybe Prelude.Text,
    -- | The ID of the network interface.
    Address -> Maybe Text
networkInterfaceId :: Prelude.Maybe Prelude.Text,
    -- | The ID of the Amazon Web Services account that owns the network
    -- interface.
    Address -> Maybe Text
networkInterfaceOwnerId :: Prelude.Maybe Prelude.Text,
    -- | The private IP address associated with the Elastic IP address.
    Address -> Maybe Text
privateIpAddress :: Prelude.Maybe Prelude.Text,
    -- | The Elastic IP address.
    Address -> Maybe Text
publicIp :: Prelude.Maybe Prelude.Text,
    -- | The ID of an address pool.
    Address -> Maybe Text
publicIpv4Pool :: Prelude.Maybe Prelude.Text,
    -- | Any tags assigned to the Elastic IP address.
    Address -> Maybe [Tag]
tags :: Prelude.Maybe [Tag]
  }
  deriving (Address -> Address -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Address -> Address -> Bool
$c/= :: Address -> Address -> Bool
== :: Address -> Address -> Bool
$c== :: Address -> Address -> Bool
Prelude.Eq, ReadPrec [Address]
ReadPrec Address
Int -> ReadS Address
ReadS [Address]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Address]
$creadListPrec :: ReadPrec [Address]
readPrec :: ReadPrec Address
$creadPrec :: ReadPrec Address
readList :: ReadS [Address]
$creadList :: ReadS [Address]
readsPrec :: Int -> ReadS Address
$creadsPrec :: Int -> ReadS Address
Prelude.Read, Int -> Address -> ShowS
[Address] -> ShowS
Address -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Address] -> ShowS
$cshowList :: [Address] -> ShowS
show :: Address -> String
$cshow :: Address -> String
showsPrec :: Int -> Address -> ShowS
$cshowsPrec :: Int -> Address -> ShowS
Prelude.Show, forall x. Rep Address x -> Address
forall x. Address -> Rep Address x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Address x -> Address
$cfrom :: forall x. Address -> Rep Address x
Prelude.Generic)

-- |
-- Create a value of 'Address' 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:
--
-- 'allocationId', 'address_allocationId' - The ID representing the allocation of the address for use with EC2-VPC.
--
-- 'associationId', 'address_associationId' - The ID representing the association of the address with an instance in a
-- VPC.
--
-- 'carrierIp', 'address_carrierIp' - The carrier IP address associated. This option is only available for
-- network interfaces which reside in a subnet in a Wavelength Zone (for
-- example an EC2 instance).
--
-- 'customerOwnedIp', 'address_customerOwnedIp' - The customer-owned IP address.
--
-- 'customerOwnedIpv4Pool', 'address_customerOwnedIpv4Pool' - The ID of the customer-owned address pool.
--
-- 'domain', 'address_domain' - Indicates whether this Elastic IP address is for use with instances in
-- EC2-Classic (@standard@) or instances in a VPC (@vpc@).
--
-- 'instanceId', 'address_instanceId' - The ID of the instance that the address is associated with (if any).
--
-- 'networkBorderGroup', 'address_networkBorderGroup' - The name of the unique set of Availability Zones, Local Zones, or
-- Wavelength Zones from which Amazon Web Services advertises IP addresses.
--
-- 'networkInterfaceId', 'address_networkInterfaceId' - The ID of the network interface.
--
-- 'networkInterfaceOwnerId', 'address_networkInterfaceOwnerId' - The ID of the Amazon Web Services account that owns the network
-- interface.
--
-- 'privateIpAddress', 'address_privateIpAddress' - The private IP address associated with the Elastic IP address.
--
-- 'publicIp', 'address_publicIp' - The Elastic IP address.
--
-- 'publicIpv4Pool', 'address_publicIpv4Pool' - The ID of an address pool.
--
-- 'tags', 'address_tags' - Any tags assigned to the Elastic IP address.
newAddress ::
  Address
newAddress :: Address
newAddress =
  Address'
    { $sel:allocationId:Address' :: Maybe Text
allocationId = forall a. Maybe a
Prelude.Nothing,
      $sel:associationId:Address' :: Maybe Text
associationId = forall a. Maybe a
Prelude.Nothing,
      $sel:carrierIp:Address' :: Maybe Text
carrierIp = forall a. Maybe a
Prelude.Nothing,
      $sel:customerOwnedIp:Address' :: Maybe Text
customerOwnedIp = forall a. Maybe a
Prelude.Nothing,
      $sel:customerOwnedIpv4Pool:Address' :: Maybe Text
customerOwnedIpv4Pool = forall a. Maybe a
Prelude.Nothing,
      $sel:domain:Address' :: Maybe DomainType
domain = forall a. Maybe a
Prelude.Nothing,
      $sel:instanceId:Address' :: Maybe Text
instanceId = forall a. Maybe a
Prelude.Nothing,
      $sel:networkBorderGroup:Address' :: Maybe Text
networkBorderGroup = forall a. Maybe a
Prelude.Nothing,
      $sel:networkInterfaceId:Address' :: Maybe Text
networkInterfaceId = forall a. Maybe a
Prelude.Nothing,
      $sel:networkInterfaceOwnerId:Address' :: Maybe Text
networkInterfaceOwnerId = forall a. Maybe a
Prelude.Nothing,
      $sel:privateIpAddress:Address' :: Maybe Text
privateIpAddress = forall a. Maybe a
Prelude.Nothing,
      $sel:publicIp:Address' :: Maybe Text
publicIp = forall a. Maybe a
Prelude.Nothing,
      $sel:publicIpv4Pool:Address' :: Maybe Text
publicIpv4Pool = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:Address' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing
    }

-- | The ID representing the allocation of the address for use with EC2-VPC.
address_allocationId :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_allocationId :: Lens' Address (Maybe Text)
address_allocationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
allocationId :: Maybe Text
$sel:allocationId:Address' :: Address -> Maybe Text
allocationId} -> Maybe Text
allocationId) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:allocationId:Address' :: Maybe Text
allocationId = Maybe Text
a} :: Address)

-- | The ID representing the association of the address with an instance in a
-- VPC.
address_associationId :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_associationId :: Lens' Address (Maybe Text)
address_associationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
associationId :: Maybe Text
$sel:associationId:Address' :: Address -> Maybe Text
associationId} -> Maybe Text
associationId) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:associationId:Address' :: Maybe Text
associationId = Maybe Text
a} :: Address)

-- | The carrier IP address associated. This option is only available for
-- network interfaces which reside in a subnet in a Wavelength Zone (for
-- example an EC2 instance).
address_carrierIp :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_carrierIp :: Lens' Address (Maybe Text)
address_carrierIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
carrierIp :: Maybe Text
$sel:carrierIp:Address' :: Address -> Maybe Text
carrierIp} -> Maybe Text
carrierIp) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:carrierIp:Address' :: Maybe Text
carrierIp = Maybe Text
a} :: Address)

-- | The customer-owned IP address.
address_customerOwnedIp :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_customerOwnedIp :: Lens' Address (Maybe Text)
address_customerOwnedIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
customerOwnedIp :: Maybe Text
$sel:customerOwnedIp:Address' :: Address -> Maybe Text
customerOwnedIp} -> Maybe Text
customerOwnedIp) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:customerOwnedIp:Address' :: Maybe Text
customerOwnedIp = Maybe Text
a} :: Address)

-- | The ID of the customer-owned address pool.
address_customerOwnedIpv4Pool :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_customerOwnedIpv4Pool :: Lens' Address (Maybe Text)
address_customerOwnedIpv4Pool = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
customerOwnedIpv4Pool :: Maybe Text
$sel:customerOwnedIpv4Pool:Address' :: Address -> Maybe Text
customerOwnedIpv4Pool} -> Maybe Text
customerOwnedIpv4Pool) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:customerOwnedIpv4Pool:Address' :: Maybe Text
customerOwnedIpv4Pool = Maybe Text
a} :: Address)

-- | Indicates whether this Elastic IP address is for use with instances in
-- EC2-Classic (@standard@) or instances in a VPC (@vpc@).
address_domain :: Lens.Lens' Address (Prelude.Maybe DomainType)
address_domain :: Lens' Address (Maybe DomainType)
address_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe DomainType
domain :: Maybe DomainType
$sel:domain:Address' :: Address -> Maybe DomainType
domain} -> Maybe DomainType
domain) (\s :: Address
s@Address' {} Maybe DomainType
a -> Address
s {$sel:domain:Address' :: Maybe DomainType
domain = Maybe DomainType
a} :: Address)

-- | The ID of the instance that the address is associated with (if any).
address_instanceId :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_instanceId :: Lens' Address (Maybe Text)
address_instanceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
instanceId :: Maybe Text
$sel:instanceId:Address' :: Address -> Maybe Text
instanceId} -> Maybe Text
instanceId) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:instanceId:Address' :: Maybe Text
instanceId = Maybe Text
a} :: Address)

-- | The name of the unique set of Availability Zones, Local Zones, or
-- Wavelength Zones from which Amazon Web Services advertises IP addresses.
address_networkBorderGroup :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_networkBorderGroup :: Lens' Address (Maybe Text)
address_networkBorderGroup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
networkBorderGroup :: Maybe Text
$sel:networkBorderGroup:Address' :: Address -> Maybe Text
networkBorderGroup} -> Maybe Text
networkBorderGroup) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:networkBorderGroup:Address' :: Maybe Text
networkBorderGroup = Maybe Text
a} :: Address)

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

-- | The ID of the Amazon Web Services account that owns the network
-- interface.
address_networkInterfaceOwnerId :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_networkInterfaceOwnerId :: Lens' Address (Maybe Text)
address_networkInterfaceOwnerId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
networkInterfaceOwnerId :: Maybe Text
$sel:networkInterfaceOwnerId:Address' :: Address -> Maybe Text
networkInterfaceOwnerId} -> Maybe Text
networkInterfaceOwnerId) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:networkInterfaceOwnerId:Address' :: Maybe Text
networkInterfaceOwnerId = Maybe Text
a} :: Address)

-- | The private IP address associated with the Elastic IP address.
address_privateIpAddress :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_privateIpAddress :: Lens' Address (Maybe Text)
address_privateIpAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
privateIpAddress :: Maybe Text
$sel:privateIpAddress:Address' :: Address -> Maybe Text
privateIpAddress} -> Maybe Text
privateIpAddress) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:privateIpAddress:Address' :: Maybe Text
privateIpAddress = Maybe Text
a} :: Address)

-- | The Elastic IP address.
address_publicIp :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_publicIp :: Lens' Address (Maybe Text)
address_publicIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
publicIp :: Maybe Text
$sel:publicIp:Address' :: Address -> Maybe Text
publicIp} -> Maybe Text
publicIp) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:publicIp:Address' :: Maybe Text
publicIp = Maybe Text
a} :: Address)

-- | The ID of an address pool.
address_publicIpv4Pool :: Lens.Lens' Address (Prelude.Maybe Prelude.Text)
address_publicIpv4Pool :: Lens' Address (Maybe Text)
address_publicIpv4Pool = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe Text
publicIpv4Pool :: Maybe Text
$sel:publicIpv4Pool:Address' :: Address -> Maybe Text
publicIpv4Pool} -> Maybe Text
publicIpv4Pool) (\s :: Address
s@Address' {} Maybe Text
a -> Address
s {$sel:publicIpv4Pool:Address' :: Maybe Text
publicIpv4Pool = Maybe Text
a} :: Address)

-- | Any tags assigned to the Elastic IP address.
address_tags :: Lens.Lens' Address (Prelude.Maybe [Tag])
address_tags :: Lens' Address (Maybe [Tag])
address_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Address' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:Address' :: Address -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: Address
s@Address' {} Maybe [Tag]
a -> Address
s {$sel:tags:Address' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: Address) 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

instance Data.FromXML Address where
  parseXML :: [Node] -> Either String Address
parseXML [Node]
x =
    Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe DomainType
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe [Tag]
-> Address
Address'
      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
"allocationId")
      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
"associationId")
      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
"carrierIp")
      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
"customerOwnedIp")
      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
"customerOwnedIpv4Pool")
      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
"domain")
      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
"instanceId")
      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
"networkBorderGroup")
      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.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"networkInterfaceOwnerId")
      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
"privateIpAddress")
      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
"publicIp")
      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
"publicIpv4Pool")
      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
"tagSet"
                      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")
                  )

instance Prelude.Hashable Address where
  hashWithSalt :: Int -> Address -> Int
hashWithSalt Int
_salt Address' {Maybe [Tag]
Maybe Text
Maybe DomainType
tags :: Maybe [Tag]
publicIpv4Pool :: Maybe Text
publicIp :: Maybe Text
privateIpAddress :: Maybe Text
networkInterfaceOwnerId :: Maybe Text
networkInterfaceId :: Maybe Text
networkBorderGroup :: Maybe Text
instanceId :: Maybe Text
domain :: Maybe DomainType
customerOwnedIpv4Pool :: Maybe Text
customerOwnedIp :: Maybe Text
carrierIp :: Maybe Text
associationId :: Maybe Text
allocationId :: Maybe Text
$sel:tags:Address' :: Address -> Maybe [Tag]
$sel:publicIpv4Pool:Address' :: Address -> Maybe Text
$sel:publicIp:Address' :: Address -> Maybe Text
$sel:privateIpAddress:Address' :: Address -> Maybe Text
$sel:networkInterfaceOwnerId:Address' :: Address -> Maybe Text
$sel:networkInterfaceId:Address' :: Address -> Maybe Text
$sel:networkBorderGroup:Address' :: Address -> Maybe Text
$sel:instanceId:Address' :: Address -> Maybe Text
$sel:domain:Address' :: Address -> Maybe DomainType
$sel:customerOwnedIpv4Pool:Address' :: Address -> Maybe Text
$sel:customerOwnedIp:Address' :: Address -> Maybe Text
$sel:carrierIp:Address' :: Address -> Maybe Text
$sel:associationId:Address' :: Address -> Maybe Text
$sel:allocationId:Address' :: Address -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
allocationId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
associationId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
carrierIp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
customerOwnedIp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
customerOwnedIpv4Pool
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DomainType
domain
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
instanceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
networkBorderGroup
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
networkInterfaceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
networkInterfaceOwnerId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
privateIpAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
publicIp
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
publicIpv4Pool
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags

instance Prelude.NFData Address where
  rnf :: Address -> ()
rnf Address' {Maybe [Tag]
Maybe Text
Maybe DomainType
tags :: Maybe [Tag]
publicIpv4Pool :: Maybe Text
publicIp :: Maybe Text
privateIpAddress :: Maybe Text
networkInterfaceOwnerId :: Maybe Text
networkInterfaceId :: Maybe Text
networkBorderGroup :: Maybe Text
instanceId :: Maybe Text
domain :: Maybe DomainType
customerOwnedIpv4Pool :: Maybe Text
customerOwnedIp :: Maybe Text
carrierIp :: Maybe Text
associationId :: Maybe Text
allocationId :: Maybe Text
$sel:tags:Address' :: Address -> Maybe [Tag]
$sel:publicIpv4Pool:Address' :: Address -> Maybe Text
$sel:publicIp:Address' :: Address -> Maybe Text
$sel:privateIpAddress:Address' :: Address -> Maybe Text
$sel:networkInterfaceOwnerId:Address' :: Address -> Maybe Text
$sel:networkInterfaceId:Address' :: Address -> Maybe Text
$sel:networkBorderGroup:Address' :: Address -> Maybe Text
$sel:instanceId:Address' :: Address -> Maybe Text
$sel:domain:Address' :: Address -> Maybe DomainType
$sel:customerOwnedIpv4Pool:Address' :: Address -> Maybe Text
$sel:customerOwnedIp:Address' :: Address -> Maybe Text
$sel:carrierIp:Address' :: Address -> Maybe Text
$sel:associationId:Address' :: Address -> Maybe Text
$sel:allocationId:Address' :: Address -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
allocationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
associationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
carrierIp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
customerOwnedIp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
customerOwnedIpv4Pool
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DomainType
domain
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
instanceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
networkBorderGroup
      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 Maybe Text
networkInterfaceOwnerId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
privateIpAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
publicIp
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
publicIpv4Pool
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags