{-# 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.Kafka.Types.BrokerNodeGroupInfo
-- 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.Kafka.Types.BrokerNodeGroupInfo where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Kafka.Types.BrokerAZDistribution
import Amazonka.Kafka.Types.ConnectivityInfo
import Amazonka.Kafka.Types.StorageInfo
import qualified Amazonka.Prelude as Prelude

-- | Describes the setup to be used for Apache Kafka broker nodes in the
-- cluster.
--
-- /See:/ 'newBrokerNodeGroupInfo' smart constructor.
data BrokerNodeGroupInfo = BrokerNodeGroupInfo'
  { -- | The distribution of broker nodes across Availability Zones. This is an
    -- optional parameter. If you don\'t specify it, Amazon MSK gives it the
    -- value DEFAULT. You can also explicitly set this parameter to the value
    -- DEFAULT. No other values are currently allowed.
    --
    -- Amazon MSK distributes the broker nodes evenly across the Availability
    -- Zones that correspond to the subnets you provide when you create the
    -- cluster.
    BrokerNodeGroupInfo -> Maybe BrokerAZDistribution
brokerAZDistribution :: Prelude.Maybe BrokerAZDistribution,
    -- | Information about the broker access configuration.
    BrokerNodeGroupInfo -> Maybe ConnectivityInfo
connectivityInfo :: Prelude.Maybe ConnectivityInfo,
    -- | The AWS security groups to associate with the elastic network interfaces
    -- in order to specify who can connect to and communicate with the Amazon
    -- MSK cluster. If you don\'t specify a security group, Amazon MSK uses the
    -- default security group associated with the VPC.
    BrokerNodeGroupInfo -> Maybe [Text]
securityGroups :: Prelude.Maybe [Prelude.Text],
    -- | Contains information about storage volumes attached to MSK broker nodes.
    BrokerNodeGroupInfo -> Maybe StorageInfo
storageInfo :: Prelude.Maybe StorageInfo,
    -- | The list of subnets to connect to in the client virtual private cloud
    -- (VPC). AWS creates elastic network interfaces inside these subnets.
    -- Client applications use elastic network interfaces to produce and
    -- consume data. Client subnets can\'t occupy the Availability Zone with ID
    -- use use1-az3.
    BrokerNodeGroupInfo -> [Text]
clientSubnets :: [Prelude.Text],
    -- | The type of Amazon EC2 instances to use for Apache Kafka brokers. The
    -- following instance types are allowed: kafka.m5.large, kafka.m5.xlarge,
    -- kafka.m5.2xlarge, kafka.m5.4xlarge, kafka.m5.12xlarge, and
    -- kafka.m5.24xlarge.
    BrokerNodeGroupInfo -> Text
instanceType :: Prelude.Text
  }
  deriving (BrokerNodeGroupInfo -> BrokerNodeGroupInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BrokerNodeGroupInfo -> BrokerNodeGroupInfo -> Bool
$c/= :: BrokerNodeGroupInfo -> BrokerNodeGroupInfo -> Bool
== :: BrokerNodeGroupInfo -> BrokerNodeGroupInfo -> Bool
$c== :: BrokerNodeGroupInfo -> BrokerNodeGroupInfo -> Bool
Prelude.Eq, ReadPrec [BrokerNodeGroupInfo]
ReadPrec BrokerNodeGroupInfo
Int -> ReadS BrokerNodeGroupInfo
ReadS [BrokerNodeGroupInfo]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BrokerNodeGroupInfo]
$creadListPrec :: ReadPrec [BrokerNodeGroupInfo]
readPrec :: ReadPrec BrokerNodeGroupInfo
$creadPrec :: ReadPrec BrokerNodeGroupInfo
readList :: ReadS [BrokerNodeGroupInfo]
$creadList :: ReadS [BrokerNodeGroupInfo]
readsPrec :: Int -> ReadS BrokerNodeGroupInfo
$creadsPrec :: Int -> ReadS BrokerNodeGroupInfo
Prelude.Read, Int -> BrokerNodeGroupInfo -> ShowS
[BrokerNodeGroupInfo] -> ShowS
BrokerNodeGroupInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BrokerNodeGroupInfo] -> ShowS
$cshowList :: [BrokerNodeGroupInfo] -> ShowS
show :: BrokerNodeGroupInfo -> String
$cshow :: BrokerNodeGroupInfo -> String
showsPrec :: Int -> BrokerNodeGroupInfo -> ShowS
$cshowsPrec :: Int -> BrokerNodeGroupInfo -> ShowS
Prelude.Show, forall x. Rep BrokerNodeGroupInfo x -> BrokerNodeGroupInfo
forall x. BrokerNodeGroupInfo -> Rep BrokerNodeGroupInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BrokerNodeGroupInfo x -> BrokerNodeGroupInfo
$cfrom :: forall x. BrokerNodeGroupInfo -> Rep BrokerNodeGroupInfo x
Prelude.Generic)

-- |
-- Create a value of 'BrokerNodeGroupInfo' 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:
--
-- 'brokerAZDistribution', 'brokerNodeGroupInfo_brokerAZDistribution' - The distribution of broker nodes across Availability Zones. This is an
-- optional parameter. If you don\'t specify it, Amazon MSK gives it the
-- value DEFAULT. You can also explicitly set this parameter to the value
-- DEFAULT. No other values are currently allowed.
--
-- Amazon MSK distributes the broker nodes evenly across the Availability
-- Zones that correspond to the subnets you provide when you create the
-- cluster.
--
-- 'connectivityInfo', 'brokerNodeGroupInfo_connectivityInfo' - Information about the broker access configuration.
--
-- 'securityGroups', 'brokerNodeGroupInfo_securityGroups' - The AWS security groups to associate with the elastic network interfaces
-- in order to specify who can connect to and communicate with the Amazon
-- MSK cluster. If you don\'t specify a security group, Amazon MSK uses the
-- default security group associated with the VPC.
--
-- 'storageInfo', 'brokerNodeGroupInfo_storageInfo' - Contains information about storage volumes attached to MSK broker nodes.
--
-- 'clientSubnets', 'brokerNodeGroupInfo_clientSubnets' - The list of subnets to connect to in the client virtual private cloud
-- (VPC). AWS creates elastic network interfaces inside these subnets.
-- Client applications use elastic network interfaces to produce and
-- consume data. Client subnets can\'t occupy the Availability Zone with ID
-- use use1-az3.
--
-- 'instanceType', 'brokerNodeGroupInfo_instanceType' - The type of Amazon EC2 instances to use for Apache Kafka brokers. The
-- following instance types are allowed: kafka.m5.large, kafka.m5.xlarge,
-- kafka.m5.2xlarge, kafka.m5.4xlarge, kafka.m5.12xlarge, and
-- kafka.m5.24xlarge.
newBrokerNodeGroupInfo ::
  -- | 'instanceType'
  Prelude.Text ->
  BrokerNodeGroupInfo
newBrokerNodeGroupInfo :: Text -> BrokerNodeGroupInfo
newBrokerNodeGroupInfo Text
pInstanceType_ =
  BrokerNodeGroupInfo'
    { $sel:brokerAZDistribution:BrokerNodeGroupInfo' :: Maybe BrokerAZDistribution
brokerAZDistribution =
        forall a. Maybe a
Prelude.Nothing,
      $sel:connectivityInfo:BrokerNodeGroupInfo' :: Maybe ConnectivityInfo
connectivityInfo = forall a. Maybe a
Prelude.Nothing,
      $sel:securityGroups:BrokerNodeGroupInfo' :: Maybe [Text]
securityGroups = forall a. Maybe a
Prelude.Nothing,
      $sel:storageInfo:BrokerNodeGroupInfo' :: Maybe StorageInfo
storageInfo = forall a. Maybe a
Prelude.Nothing,
      $sel:clientSubnets:BrokerNodeGroupInfo' :: [Text]
clientSubnets = forall a. Monoid a => a
Prelude.mempty,
      $sel:instanceType:BrokerNodeGroupInfo' :: Text
instanceType = Text
pInstanceType_
    }

-- | The distribution of broker nodes across Availability Zones. This is an
-- optional parameter. If you don\'t specify it, Amazon MSK gives it the
-- value DEFAULT. You can also explicitly set this parameter to the value
-- DEFAULT. No other values are currently allowed.
--
-- Amazon MSK distributes the broker nodes evenly across the Availability
-- Zones that correspond to the subnets you provide when you create the
-- cluster.
brokerNodeGroupInfo_brokerAZDistribution :: Lens.Lens' BrokerNodeGroupInfo (Prelude.Maybe BrokerAZDistribution)
brokerNodeGroupInfo_brokerAZDistribution :: Lens' BrokerNodeGroupInfo (Maybe BrokerAZDistribution)
brokerNodeGroupInfo_brokerAZDistribution = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BrokerNodeGroupInfo' {Maybe BrokerAZDistribution
brokerAZDistribution :: Maybe BrokerAZDistribution
$sel:brokerAZDistribution:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe BrokerAZDistribution
brokerAZDistribution} -> Maybe BrokerAZDistribution
brokerAZDistribution) (\s :: BrokerNodeGroupInfo
s@BrokerNodeGroupInfo' {} Maybe BrokerAZDistribution
a -> BrokerNodeGroupInfo
s {$sel:brokerAZDistribution:BrokerNodeGroupInfo' :: Maybe BrokerAZDistribution
brokerAZDistribution = Maybe BrokerAZDistribution
a} :: BrokerNodeGroupInfo)

-- | Information about the broker access configuration.
brokerNodeGroupInfo_connectivityInfo :: Lens.Lens' BrokerNodeGroupInfo (Prelude.Maybe ConnectivityInfo)
brokerNodeGroupInfo_connectivityInfo :: Lens' BrokerNodeGroupInfo (Maybe ConnectivityInfo)
brokerNodeGroupInfo_connectivityInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BrokerNodeGroupInfo' {Maybe ConnectivityInfo
connectivityInfo :: Maybe ConnectivityInfo
$sel:connectivityInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe ConnectivityInfo
connectivityInfo} -> Maybe ConnectivityInfo
connectivityInfo) (\s :: BrokerNodeGroupInfo
s@BrokerNodeGroupInfo' {} Maybe ConnectivityInfo
a -> BrokerNodeGroupInfo
s {$sel:connectivityInfo:BrokerNodeGroupInfo' :: Maybe ConnectivityInfo
connectivityInfo = Maybe ConnectivityInfo
a} :: BrokerNodeGroupInfo)

-- | The AWS security groups to associate with the elastic network interfaces
-- in order to specify who can connect to and communicate with the Amazon
-- MSK cluster. If you don\'t specify a security group, Amazon MSK uses the
-- default security group associated with the VPC.
brokerNodeGroupInfo_securityGroups :: Lens.Lens' BrokerNodeGroupInfo (Prelude.Maybe [Prelude.Text])
brokerNodeGroupInfo_securityGroups :: Lens' BrokerNodeGroupInfo (Maybe [Text])
brokerNodeGroupInfo_securityGroups = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BrokerNodeGroupInfo' {Maybe [Text]
securityGroups :: Maybe [Text]
$sel:securityGroups:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe [Text]
securityGroups} -> Maybe [Text]
securityGroups) (\s :: BrokerNodeGroupInfo
s@BrokerNodeGroupInfo' {} Maybe [Text]
a -> BrokerNodeGroupInfo
s {$sel:securityGroups:BrokerNodeGroupInfo' :: Maybe [Text]
securityGroups = Maybe [Text]
a} :: BrokerNodeGroupInfo) 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

-- | Contains information about storage volumes attached to MSK broker nodes.
brokerNodeGroupInfo_storageInfo :: Lens.Lens' BrokerNodeGroupInfo (Prelude.Maybe StorageInfo)
brokerNodeGroupInfo_storageInfo :: Lens' BrokerNodeGroupInfo (Maybe StorageInfo)
brokerNodeGroupInfo_storageInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BrokerNodeGroupInfo' {Maybe StorageInfo
storageInfo :: Maybe StorageInfo
$sel:storageInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe StorageInfo
storageInfo} -> Maybe StorageInfo
storageInfo) (\s :: BrokerNodeGroupInfo
s@BrokerNodeGroupInfo' {} Maybe StorageInfo
a -> BrokerNodeGroupInfo
s {$sel:storageInfo:BrokerNodeGroupInfo' :: Maybe StorageInfo
storageInfo = Maybe StorageInfo
a} :: BrokerNodeGroupInfo)

-- | The list of subnets to connect to in the client virtual private cloud
-- (VPC). AWS creates elastic network interfaces inside these subnets.
-- Client applications use elastic network interfaces to produce and
-- consume data. Client subnets can\'t occupy the Availability Zone with ID
-- use use1-az3.
brokerNodeGroupInfo_clientSubnets :: Lens.Lens' BrokerNodeGroupInfo [Prelude.Text]
brokerNodeGroupInfo_clientSubnets :: Lens' BrokerNodeGroupInfo [Text]
brokerNodeGroupInfo_clientSubnets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BrokerNodeGroupInfo' {[Text]
clientSubnets :: [Text]
$sel:clientSubnets:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> [Text]
clientSubnets} -> [Text]
clientSubnets) (\s :: BrokerNodeGroupInfo
s@BrokerNodeGroupInfo' {} [Text]
a -> BrokerNodeGroupInfo
s {$sel:clientSubnets:BrokerNodeGroupInfo' :: [Text]
clientSubnets = [Text]
a} :: BrokerNodeGroupInfo) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The type of Amazon EC2 instances to use for Apache Kafka brokers. The
-- following instance types are allowed: kafka.m5.large, kafka.m5.xlarge,
-- kafka.m5.2xlarge, kafka.m5.4xlarge, kafka.m5.12xlarge, and
-- kafka.m5.24xlarge.
brokerNodeGroupInfo_instanceType :: Lens.Lens' BrokerNodeGroupInfo Prelude.Text
brokerNodeGroupInfo_instanceType :: Lens' BrokerNodeGroupInfo Text
brokerNodeGroupInfo_instanceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BrokerNodeGroupInfo' {Text
instanceType :: Text
$sel:instanceType:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Text
instanceType} -> Text
instanceType) (\s :: BrokerNodeGroupInfo
s@BrokerNodeGroupInfo' {} Text
a -> BrokerNodeGroupInfo
s {$sel:instanceType:BrokerNodeGroupInfo' :: Text
instanceType = Text
a} :: BrokerNodeGroupInfo)

instance Data.FromJSON BrokerNodeGroupInfo where
  parseJSON :: Value -> Parser BrokerNodeGroupInfo
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"BrokerNodeGroupInfo"
      ( \Object
x ->
          Maybe BrokerAZDistribution
-> Maybe ConnectivityInfo
-> Maybe [Text]
-> Maybe StorageInfo
-> [Text]
-> Text
-> BrokerNodeGroupInfo
BrokerNodeGroupInfo'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"brokerAZDistribution")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"connectivityInfo")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"securityGroups" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"storageInfo")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"clientSubnets" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"instanceType")
      )

instance Prelude.Hashable BrokerNodeGroupInfo where
  hashWithSalt :: Int -> BrokerNodeGroupInfo -> Int
hashWithSalt Int
_salt BrokerNodeGroupInfo' {[Text]
Maybe [Text]
Maybe BrokerAZDistribution
Maybe ConnectivityInfo
Maybe StorageInfo
Text
instanceType :: Text
clientSubnets :: [Text]
storageInfo :: Maybe StorageInfo
securityGroups :: Maybe [Text]
connectivityInfo :: Maybe ConnectivityInfo
brokerAZDistribution :: Maybe BrokerAZDistribution
$sel:instanceType:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Text
$sel:clientSubnets:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> [Text]
$sel:storageInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe StorageInfo
$sel:securityGroups:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe [Text]
$sel:connectivityInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe ConnectivityInfo
$sel:brokerAZDistribution:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe BrokerAZDistribution
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe BrokerAZDistribution
brokerAZDistribution
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ConnectivityInfo
connectivityInfo
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
securityGroups
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StorageInfo
storageInfo
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
clientSubnets
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
instanceType

instance Prelude.NFData BrokerNodeGroupInfo where
  rnf :: BrokerNodeGroupInfo -> ()
rnf BrokerNodeGroupInfo' {[Text]
Maybe [Text]
Maybe BrokerAZDistribution
Maybe ConnectivityInfo
Maybe StorageInfo
Text
instanceType :: Text
clientSubnets :: [Text]
storageInfo :: Maybe StorageInfo
securityGroups :: Maybe [Text]
connectivityInfo :: Maybe ConnectivityInfo
brokerAZDistribution :: Maybe BrokerAZDistribution
$sel:instanceType:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Text
$sel:clientSubnets:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> [Text]
$sel:storageInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe StorageInfo
$sel:securityGroups:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe [Text]
$sel:connectivityInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe ConnectivityInfo
$sel:brokerAZDistribution:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe BrokerAZDistribution
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe BrokerAZDistribution
brokerAZDistribution
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConnectivityInfo
connectivityInfo
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
securityGroups
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StorageInfo
storageInfo
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
clientSubnets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
instanceType

instance Data.ToJSON BrokerNodeGroupInfo where
  toJSON :: BrokerNodeGroupInfo -> Value
toJSON BrokerNodeGroupInfo' {[Text]
Maybe [Text]
Maybe BrokerAZDistribution
Maybe ConnectivityInfo
Maybe StorageInfo
Text
instanceType :: Text
clientSubnets :: [Text]
storageInfo :: Maybe StorageInfo
securityGroups :: Maybe [Text]
connectivityInfo :: Maybe ConnectivityInfo
brokerAZDistribution :: Maybe BrokerAZDistribution
$sel:instanceType:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Text
$sel:clientSubnets:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> [Text]
$sel:storageInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe StorageInfo
$sel:securityGroups:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe [Text]
$sel:connectivityInfo:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe ConnectivityInfo
$sel:brokerAZDistribution:BrokerNodeGroupInfo' :: BrokerNodeGroupInfo -> Maybe BrokerAZDistribution
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"brokerAZDistribution" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BrokerAZDistribution
brokerAZDistribution,
            (Key
"connectivityInfo" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ConnectivityInfo
connectivityInfo,
            (Key
"securityGroups" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
securityGroups,
            (Key
"storageInfo" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe StorageInfo
storageInfo,
            forall a. a -> Maybe a
Prelude.Just (Key
"clientSubnets" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Text]
clientSubnets),
            forall a. a -> Maybe a
Prelude.Just (Key
"instanceType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
instanceType)
          ]
      )