{-# 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.AvailabilityZone
-- 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.AvailabilityZone 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.AvailabilityZoneMessage
import Amazonka.EC2.Types.AvailabilityZoneOptInStatus
import Amazonka.EC2.Types.AvailabilityZoneState
import qualified Amazonka.Prelude as Prelude

-- | Describes Availability Zones, Local Zones, and Wavelength Zones.
--
-- /See:/ 'newAvailabilityZone' smart constructor.
data AvailabilityZone = AvailabilityZone'
  { -- | For Availability Zones, this parameter has the same value as the Region
    -- name.
    --
    -- For Local Zones, the name of the associated group, for example
    -- @us-west-2-lax-1@.
    --
    -- For Wavelength Zones, the name of the associated group, for example
    -- @us-east-1-wl1-bos-wlz-1@.
    AvailabilityZone -> Maybe Text
groupName :: Prelude.Maybe Prelude.Text,
    -- | Any messages about the Availability Zone, Local Zone, or Wavelength
    -- Zone.
    AvailabilityZone -> Maybe [AvailabilityZoneMessage]
messages :: Prelude.Maybe [AvailabilityZoneMessage],
    -- | The name of the network border group.
    AvailabilityZone -> Maybe Text
networkBorderGroup :: Prelude.Maybe Prelude.Text,
    -- | For Availability Zones, this parameter always has the value of
    -- @opt-in-not-required@.
    --
    -- For Local Zones and Wavelength Zones, this parameter is the opt-in
    -- status. The possible values are @opted-in@, and @not-opted-in@.
    AvailabilityZone -> Maybe AvailabilityZoneOptInStatus
optInStatus :: Prelude.Maybe AvailabilityZoneOptInStatus,
    -- | The ID of the zone that handles some of the Local Zone or Wavelength
    -- Zone control plane operations, such as API calls.
    AvailabilityZone -> Maybe Text
parentZoneId :: Prelude.Maybe Prelude.Text,
    -- | The name of the zone that handles some of the Local Zone or Wavelength
    -- Zone control plane operations, such as API calls.
    AvailabilityZone -> Maybe Text
parentZoneName :: Prelude.Maybe Prelude.Text,
    -- | The name of the Region.
    AvailabilityZone -> Maybe Text
regionName :: Prelude.Maybe Prelude.Text,
    -- | The state of the Availability Zone, Local Zone, or Wavelength Zone. This
    -- value is always @available@.
    AvailabilityZone -> Maybe AvailabilityZoneState
state :: Prelude.Maybe AvailabilityZoneState,
    -- | The ID of the Availability Zone, Local Zone, or Wavelength Zone.
    AvailabilityZone -> Maybe Text
zoneId :: Prelude.Maybe Prelude.Text,
    -- | The name of the Availability Zone, Local Zone, or Wavelength Zone.
    AvailabilityZone -> Maybe Text
zoneName :: Prelude.Maybe Prelude.Text,
    -- | The type of zone. The valid values are @availability-zone@,
    -- @local-zone@, and @wavelength-zone@.
    AvailabilityZone -> Maybe Text
zoneType :: Prelude.Maybe Prelude.Text
  }
  deriving (AvailabilityZone -> AvailabilityZone -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AvailabilityZone -> AvailabilityZone -> Bool
$c/= :: AvailabilityZone -> AvailabilityZone -> Bool
== :: AvailabilityZone -> AvailabilityZone -> Bool
$c== :: AvailabilityZone -> AvailabilityZone -> Bool
Prelude.Eq, ReadPrec [AvailabilityZone]
ReadPrec AvailabilityZone
Int -> ReadS AvailabilityZone
ReadS [AvailabilityZone]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AvailabilityZone]
$creadListPrec :: ReadPrec [AvailabilityZone]
readPrec :: ReadPrec AvailabilityZone
$creadPrec :: ReadPrec AvailabilityZone
readList :: ReadS [AvailabilityZone]
$creadList :: ReadS [AvailabilityZone]
readsPrec :: Int -> ReadS AvailabilityZone
$creadsPrec :: Int -> ReadS AvailabilityZone
Prelude.Read, Int -> AvailabilityZone -> ShowS
[AvailabilityZone] -> ShowS
AvailabilityZone -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AvailabilityZone] -> ShowS
$cshowList :: [AvailabilityZone] -> ShowS
show :: AvailabilityZone -> String
$cshow :: AvailabilityZone -> String
showsPrec :: Int -> AvailabilityZone -> ShowS
$cshowsPrec :: Int -> AvailabilityZone -> ShowS
Prelude.Show, forall x. Rep AvailabilityZone x -> AvailabilityZone
forall x. AvailabilityZone -> Rep AvailabilityZone x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AvailabilityZone x -> AvailabilityZone
$cfrom :: forall x. AvailabilityZone -> Rep AvailabilityZone x
Prelude.Generic)

-- |
-- Create a value of 'AvailabilityZone' 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:
--
-- 'groupName', 'availabilityZone_groupName' - For Availability Zones, this parameter has the same value as the Region
-- name.
--
-- For Local Zones, the name of the associated group, for example
-- @us-west-2-lax-1@.
--
-- For Wavelength Zones, the name of the associated group, for example
-- @us-east-1-wl1-bos-wlz-1@.
--
-- 'messages', 'availabilityZone_messages' - Any messages about the Availability Zone, Local Zone, or Wavelength
-- Zone.
--
-- 'networkBorderGroup', 'availabilityZone_networkBorderGroup' - The name of the network border group.
--
-- 'optInStatus', 'availabilityZone_optInStatus' - For Availability Zones, this parameter always has the value of
-- @opt-in-not-required@.
--
-- For Local Zones and Wavelength Zones, this parameter is the opt-in
-- status. The possible values are @opted-in@, and @not-opted-in@.
--
-- 'parentZoneId', 'availabilityZone_parentZoneId' - The ID of the zone that handles some of the Local Zone or Wavelength
-- Zone control plane operations, such as API calls.
--
-- 'parentZoneName', 'availabilityZone_parentZoneName' - The name of the zone that handles some of the Local Zone or Wavelength
-- Zone control plane operations, such as API calls.
--
-- 'regionName', 'availabilityZone_regionName' - The name of the Region.
--
-- 'state', 'availabilityZone_state' - The state of the Availability Zone, Local Zone, or Wavelength Zone. This
-- value is always @available@.
--
-- 'zoneId', 'availabilityZone_zoneId' - The ID of the Availability Zone, Local Zone, or Wavelength Zone.
--
-- 'zoneName', 'availabilityZone_zoneName' - The name of the Availability Zone, Local Zone, or Wavelength Zone.
--
-- 'zoneType', 'availabilityZone_zoneType' - The type of zone. The valid values are @availability-zone@,
-- @local-zone@, and @wavelength-zone@.
newAvailabilityZone ::
  AvailabilityZone
newAvailabilityZone :: AvailabilityZone
newAvailabilityZone =
  AvailabilityZone'
    { $sel:groupName:AvailabilityZone' :: Maybe Text
groupName = forall a. Maybe a
Prelude.Nothing,
      $sel:messages:AvailabilityZone' :: Maybe [AvailabilityZoneMessage]
messages = forall a. Maybe a
Prelude.Nothing,
      $sel:networkBorderGroup:AvailabilityZone' :: Maybe Text
networkBorderGroup = forall a. Maybe a
Prelude.Nothing,
      $sel:optInStatus:AvailabilityZone' :: Maybe AvailabilityZoneOptInStatus
optInStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:parentZoneId:AvailabilityZone' :: Maybe Text
parentZoneId = forall a. Maybe a
Prelude.Nothing,
      $sel:parentZoneName:AvailabilityZone' :: Maybe Text
parentZoneName = forall a. Maybe a
Prelude.Nothing,
      $sel:regionName:AvailabilityZone' :: Maybe Text
regionName = forall a. Maybe a
Prelude.Nothing,
      $sel:state:AvailabilityZone' :: Maybe AvailabilityZoneState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:zoneId:AvailabilityZone' :: Maybe Text
zoneId = forall a. Maybe a
Prelude.Nothing,
      $sel:zoneName:AvailabilityZone' :: Maybe Text
zoneName = forall a. Maybe a
Prelude.Nothing,
      $sel:zoneType:AvailabilityZone' :: Maybe Text
zoneType = forall a. Maybe a
Prelude.Nothing
    }

-- | For Availability Zones, this parameter has the same value as the Region
-- name.
--
-- For Local Zones, the name of the associated group, for example
-- @us-west-2-lax-1@.
--
-- For Wavelength Zones, the name of the associated group, for example
-- @us-east-1-wl1-bos-wlz-1@.
availabilityZone_groupName :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_groupName :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_groupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
groupName :: Maybe Text
$sel:groupName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
groupName} -> Maybe Text
groupName) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:groupName:AvailabilityZone' :: Maybe Text
groupName = Maybe Text
a} :: AvailabilityZone)

-- | Any messages about the Availability Zone, Local Zone, or Wavelength
-- Zone.
availabilityZone_messages :: Lens.Lens' AvailabilityZone (Prelude.Maybe [AvailabilityZoneMessage])
availabilityZone_messages :: Lens' AvailabilityZone (Maybe [AvailabilityZoneMessage])
availabilityZone_messages = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe [AvailabilityZoneMessage]
messages :: Maybe [AvailabilityZoneMessage]
$sel:messages:AvailabilityZone' :: AvailabilityZone -> Maybe [AvailabilityZoneMessage]
messages} -> Maybe [AvailabilityZoneMessage]
messages) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe [AvailabilityZoneMessage]
a -> AvailabilityZone
s {$sel:messages:AvailabilityZone' :: Maybe [AvailabilityZoneMessage]
messages = Maybe [AvailabilityZoneMessage]
a} :: AvailabilityZone) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the network border group.
availabilityZone_networkBorderGroup :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_networkBorderGroup :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_networkBorderGroup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
networkBorderGroup :: Maybe Text
$sel:networkBorderGroup:AvailabilityZone' :: AvailabilityZone -> Maybe Text
networkBorderGroup} -> Maybe Text
networkBorderGroup) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:networkBorderGroup:AvailabilityZone' :: Maybe Text
networkBorderGroup = Maybe Text
a} :: AvailabilityZone)

-- | For Availability Zones, this parameter always has the value of
-- @opt-in-not-required@.
--
-- For Local Zones and Wavelength Zones, this parameter is the opt-in
-- status. The possible values are @opted-in@, and @not-opted-in@.
availabilityZone_optInStatus :: Lens.Lens' AvailabilityZone (Prelude.Maybe AvailabilityZoneOptInStatus)
availabilityZone_optInStatus :: Lens' AvailabilityZone (Maybe AvailabilityZoneOptInStatus)
availabilityZone_optInStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe AvailabilityZoneOptInStatus
optInStatus :: Maybe AvailabilityZoneOptInStatus
$sel:optInStatus:AvailabilityZone' :: AvailabilityZone -> Maybe AvailabilityZoneOptInStatus
optInStatus} -> Maybe AvailabilityZoneOptInStatus
optInStatus) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe AvailabilityZoneOptInStatus
a -> AvailabilityZone
s {$sel:optInStatus:AvailabilityZone' :: Maybe AvailabilityZoneOptInStatus
optInStatus = Maybe AvailabilityZoneOptInStatus
a} :: AvailabilityZone)

-- | The ID of the zone that handles some of the Local Zone or Wavelength
-- Zone control plane operations, such as API calls.
availabilityZone_parentZoneId :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_parentZoneId :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_parentZoneId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
parentZoneId :: Maybe Text
$sel:parentZoneId:AvailabilityZone' :: AvailabilityZone -> Maybe Text
parentZoneId} -> Maybe Text
parentZoneId) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:parentZoneId:AvailabilityZone' :: Maybe Text
parentZoneId = Maybe Text
a} :: AvailabilityZone)

-- | The name of the zone that handles some of the Local Zone or Wavelength
-- Zone control plane operations, such as API calls.
availabilityZone_parentZoneName :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_parentZoneName :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_parentZoneName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
parentZoneName :: Maybe Text
$sel:parentZoneName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
parentZoneName} -> Maybe Text
parentZoneName) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:parentZoneName:AvailabilityZone' :: Maybe Text
parentZoneName = Maybe Text
a} :: AvailabilityZone)

-- | The name of the Region.
availabilityZone_regionName :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_regionName :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_regionName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
regionName :: Maybe Text
$sel:regionName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
regionName} -> Maybe Text
regionName) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:regionName:AvailabilityZone' :: Maybe Text
regionName = Maybe Text
a} :: AvailabilityZone)

-- | The state of the Availability Zone, Local Zone, or Wavelength Zone. This
-- value is always @available@.
availabilityZone_state :: Lens.Lens' AvailabilityZone (Prelude.Maybe AvailabilityZoneState)
availabilityZone_state :: Lens' AvailabilityZone (Maybe AvailabilityZoneState)
availabilityZone_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe AvailabilityZoneState
state :: Maybe AvailabilityZoneState
$sel:state:AvailabilityZone' :: AvailabilityZone -> Maybe AvailabilityZoneState
state} -> Maybe AvailabilityZoneState
state) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe AvailabilityZoneState
a -> AvailabilityZone
s {$sel:state:AvailabilityZone' :: Maybe AvailabilityZoneState
state = Maybe AvailabilityZoneState
a} :: AvailabilityZone)

-- | The ID of the Availability Zone, Local Zone, or Wavelength Zone.
availabilityZone_zoneId :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_zoneId :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_zoneId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
zoneId :: Maybe Text
$sel:zoneId:AvailabilityZone' :: AvailabilityZone -> Maybe Text
zoneId} -> Maybe Text
zoneId) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:zoneId:AvailabilityZone' :: Maybe Text
zoneId = Maybe Text
a} :: AvailabilityZone)

-- | The name of the Availability Zone, Local Zone, or Wavelength Zone.
availabilityZone_zoneName :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_zoneName :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_zoneName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
zoneName :: Maybe Text
$sel:zoneName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
zoneName} -> Maybe Text
zoneName) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:zoneName:AvailabilityZone' :: Maybe Text
zoneName = Maybe Text
a} :: AvailabilityZone)

-- | The type of zone. The valid values are @availability-zone@,
-- @local-zone@, and @wavelength-zone@.
availabilityZone_zoneType :: Lens.Lens' AvailabilityZone (Prelude.Maybe Prelude.Text)
availabilityZone_zoneType :: Lens' AvailabilityZone (Maybe Text)
availabilityZone_zoneType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AvailabilityZone' {Maybe Text
zoneType :: Maybe Text
$sel:zoneType:AvailabilityZone' :: AvailabilityZone -> Maybe Text
zoneType} -> Maybe Text
zoneType) (\s :: AvailabilityZone
s@AvailabilityZone' {} Maybe Text
a -> AvailabilityZone
s {$sel:zoneType:AvailabilityZone' :: Maybe Text
zoneType = Maybe Text
a} :: AvailabilityZone)

instance Data.FromXML AvailabilityZone where
  parseXML :: [Node] -> Either String AvailabilityZone
parseXML [Node]
x =
    Maybe Text
-> Maybe [AvailabilityZoneMessage]
-> Maybe Text
-> Maybe AvailabilityZoneOptInStatus
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe AvailabilityZoneState
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> AvailabilityZone
AvailabilityZone'
      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
"groupName")
      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
"messageSet"
                      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
"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
"optInStatus")
      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
"parentZoneId")
      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
"parentZoneName")
      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
"regionName")
      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
"zoneState")
      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
"zoneId")
      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
"zoneName")
      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
"zoneType")

instance Prelude.Hashable AvailabilityZone where
  hashWithSalt :: Int -> AvailabilityZone -> Int
hashWithSalt Int
_salt AvailabilityZone' {Maybe [AvailabilityZoneMessage]
Maybe Text
Maybe AvailabilityZoneOptInStatus
Maybe AvailabilityZoneState
zoneType :: Maybe Text
zoneName :: Maybe Text
zoneId :: Maybe Text
state :: Maybe AvailabilityZoneState
regionName :: Maybe Text
parentZoneName :: Maybe Text
parentZoneId :: Maybe Text
optInStatus :: Maybe AvailabilityZoneOptInStatus
networkBorderGroup :: Maybe Text
messages :: Maybe [AvailabilityZoneMessage]
groupName :: Maybe Text
$sel:zoneType:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:zoneName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:zoneId:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:state:AvailabilityZone' :: AvailabilityZone -> Maybe AvailabilityZoneState
$sel:regionName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:parentZoneName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:parentZoneId:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:optInStatus:AvailabilityZone' :: AvailabilityZone -> Maybe AvailabilityZoneOptInStatus
$sel:networkBorderGroup:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:messages:AvailabilityZone' :: AvailabilityZone -> Maybe [AvailabilityZoneMessage]
$sel:groupName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
groupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [AvailabilityZoneMessage]
messages
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
networkBorderGroup
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AvailabilityZoneOptInStatus
optInStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
parentZoneId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
parentZoneName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
regionName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AvailabilityZoneState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
zoneId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
zoneName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
zoneType

instance Prelude.NFData AvailabilityZone where
  rnf :: AvailabilityZone -> ()
rnf AvailabilityZone' {Maybe [AvailabilityZoneMessage]
Maybe Text
Maybe AvailabilityZoneOptInStatus
Maybe AvailabilityZoneState
zoneType :: Maybe Text
zoneName :: Maybe Text
zoneId :: Maybe Text
state :: Maybe AvailabilityZoneState
regionName :: Maybe Text
parentZoneName :: Maybe Text
parentZoneId :: Maybe Text
optInStatus :: Maybe AvailabilityZoneOptInStatus
networkBorderGroup :: Maybe Text
messages :: Maybe [AvailabilityZoneMessage]
groupName :: Maybe Text
$sel:zoneType:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:zoneName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:zoneId:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:state:AvailabilityZone' :: AvailabilityZone -> Maybe AvailabilityZoneState
$sel:regionName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:parentZoneName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:parentZoneId:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:optInStatus:AvailabilityZone' :: AvailabilityZone -> Maybe AvailabilityZoneOptInStatus
$sel:networkBorderGroup:AvailabilityZone' :: AvailabilityZone -> Maybe Text
$sel:messages:AvailabilityZone' :: AvailabilityZone -> Maybe [AvailabilityZoneMessage]
$sel:groupName:AvailabilityZone' :: AvailabilityZone -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
groupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [AvailabilityZoneMessage]
messages
      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 AvailabilityZoneOptInStatus
optInStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
parentZoneId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
parentZoneName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
regionName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AvailabilityZoneState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
zoneId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
zoneName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
zoneType