{-# 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.Lightsail.Types.LoadBalancer
-- 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.Lightsail.Types.LoadBalancer where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Lightsail.Types.InstanceHealthSummary
import Amazonka.Lightsail.Types.IpAddressType
import Amazonka.Lightsail.Types.LoadBalancerAttributeName
import Amazonka.Lightsail.Types.LoadBalancerProtocol
import Amazonka.Lightsail.Types.LoadBalancerState
import Amazonka.Lightsail.Types.LoadBalancerTlsCertificateSummary
import Amazonka.Lightsail.Types.ResourceLocation
import Amazonka.Lightsail.Types.ResourceType
import Amazonka.Lightsail.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes a load balancer.
--
-- /See:/ 'newLoadBalancer' smart constructor.
data LoadBalancer = LoadBalancer'
  { -- | The Amazon Resource Name (ARN) of the load balancer.
    LoadBalancer -> Maybe Text
arn :: Prelude.Maybe Prelude.Text,
    -- | A string to string map of the configuration options for your load
    -- balancer. Valid values are listed below.
    LoadBalancer -> Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions :: Prelude.Maybe (Prelude.HashMap LoadBalancerAttributeName Prelude.Text),
    -- | The date when your load balancer was created.
    LoadBalancer -> Maybe POSIX
createdAt :: Prelude.Maybe Data.POSIX,
    -- | The DNS name of your Lightsail load balancer.
    LoadBalancer -> Maybe Text
dnsName :: Prelude.Maybe Prelude.Text,
    -- | The path you specified to perform your health checks. If no path is
    -- specified, the load balancer tries to make a request to the default
    -- (root) page.
    LoadBalancer -> Maybe Text
healthCheckPath :: Prelude.Maybe Prelude.Text,
    -- | A Boolean value that indicates whether HTTPS redirection is enabled for
    -- the load balancer.
    LoadBalancer -> Maybe Bool
httpsRedirectionEnabled :: Prelude.Maybe Prelude.Bool,
    -- | An array of InstanceHealthSummary objects describing the health of the
    -- load balancer.
    LoadBalancer -> Maybe [InstanceHealthSummary]
instanceHealthSummary :: Prelude.Maybe [InstanceHealthSummary],
    -- | The port where the load balancer will direct traffic to your Lightsail
    -- instances. For HTTP traffic, it\'s port 80. For HTTPS traffic, it\'s
    -- port 443.
    LoadBalancer -> Maybe Int
instancePort :: Prelude.Maybe Prelude.Int,
    -- | The IP address type of the load balancer.
    --
    -- The possible values are @ipv4@ for IPv4 only, and @dualstack@ for IPv4
    -- and IPv6.
    LoadBalancer -> Maybe IpAddressType
ipAddressType :: Prelude.Maybe IpAddressType,
    -- | The AWS Region where your load balancer was created (e.g.,
    -- @us-east-2a@). Lightsail automatically creates your load balancer across
    -- Availability Zones.
    LoadBalancer -> Maybe ResourceLocation
location :: Prelude.Maybe ResourceLocation,
    -- | The name of the load balancer (e.g., @my-load-balancer@).
    LoadBalancer -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The protocol you have enabled for your load balancer. Valid values are
    -- below.
    --
    -- You can\'t just have @HTTP_HTTPS@, but you can have just @HTTP@.
    LoadBalancer -> Maybe LoadBalancerProtocol
protocol :: Prelude.Maybe LoadBalancerProtocol,
    -- | An array of public port settings for your load balancer. For HTTP, use
    -- port 80. For HTTPS, use port 443.
    LoadBalancer -> Maybe [Int]
publicPorts :: Prelude.Maybe [Prelude.Int],
    -- | The resource type (e.g., @LoadBalancer@.
    LoadBalancer -> Maybe ResourceType
resourceType :: Prelude.Maybe ResourceType,
    -- | The status of your load balancer. Valid values are below.
    LoadBalancer -> Maybe LoadBalancerState
state :: Prelude.Maybe LoadBalancerState,
    -- | The support code. Include this code in your email to support when you
    -- have questions about your Lightsail load balancer. This code enables our
    -- support team to look up your Lightsail information more easily.
    LoadBalancer -> Maybe Text
supportCode :: Prelude.Maybe Prelude.Text,
    -- | The tag keys and optional values for the resource. For more information
    -- about tags in Lightsail, see the
    -- <https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-tags Amazon Lightsail Developer Guide>.
    LoadBalancer -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | An array of LoadBalancerTlsCertificateSummary objects that provide
    -- additional information about the SSL\/TLS certificates. For example, if
    -- @true@, the certificate is attached to the load balancer.
    LoadBalancer -> Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries :: Prelude.Maybe [LoadBalancerTlsCertificateSummary],
    -- | The name of the TLS security policy for the load balancer.
    LoadBalancer -> Maybe Text
tlsPolicyName :: Prelude.Maybe Prelude.Text
  }
  deriving (LoadBalancer -> LoadBalancer -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LoadBalancer -> LoadBalancer -> Bool
$c/= :: LoadBalancer -> LoadBalancer -> Bool
== :: LoadBalancer -> LoadBalancer -> Bool
$c== :: LoadBalancer -> LoadBalancer -> Bool
Prelude.Eq, ReadPrec [LoadBalancer]
ReadPrec LoadBalancer
Int -> ReadS LoadBalancer
ReadS [LoadBalancer]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LoadBalancer]
$creadListPrec :: ReadPrec [LoadBalancer]
readPrec :: ReadPrec LoadBalancer
$creadPrec :: ReadPrec LoadBalancer
readList :: ReadS [LoadBalancer]
$creadList :: ReadS [LoadBalancer]
readsPrec :: Int -> ReadS LoadBalancer
$creadsPrec :: Int -> ReadS LoadBalancer
Prelude.Read, Int -> LoadBalancer -> ShowS
[LoadBalancer] -> ShowS
LoadBalancer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LoadBalancer] -> ShowS
$cshowList :: [LoadBalancer] -> ShowS
show :: LoadBalancer -> String
$cshow :: LoadBalancer -> String
showsPrec :: Int -> LoadBalancer -> ShowS
$cshowsPrec :: Int -> LoadBalancer -> ShowS
Prelude.Show, forall x. Rep LoadBalancer x -> LoadBalancer
forall x. LoadBalancer -> Rep LoadBalancer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LoadBalancer x -> LoadBalancer
$cfrom :: forall x. LoadBalancer -> Rep LoadBalancer x
Prelude.Generic)

-- |
-- Create a value of 'LoadBalancer' 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:
--
-- 'arn', 'loadBalancer_arn' - The Amazon Resource Name (ARN) of the load balancer.
--
-- 'configurationOptions', 'loadBalancer_configurationOptions' - A string to string map of the configuration options for your load
-- balancer. Valid values are listed below.
--
-- 'createdAt', 'loadBalancer_createdAt' - The date when your load balancer was created.
--
-- 'dnsName', 'loadBalancer_dnsName' - The DNS name of your Lightsail load balancer.
--
-- 'healthCheckPath', 'loadBalancer_healthCheckPath' - The path you specified to perform your health checks. If no path is
-- specified, the load balancer tries to make a request to the default
-- (root) page.
--
-- 'httpsRedirectionEnabled', 'loadBalancer_httpsRedirectionEnabled' - A Boolean value that indicates whether HTTPS redirection is enabled for
-- the load balancer.
--
-- 'instanceHealthSummary', 'loadBalancer_instanceHealthSummary' - An array of InstanceHealthSummary objects describing the health of the
-- load balancer.
--
-- 'instancePort', 'loadBalancer_instancePort' - The port where the load balancer will direct traffic to your Lightsail
-- instances. For HTTP traffic, it\'s port 80. For HTTPS traffic, it\'s
-- port 443.
--
-- 'ipAddressType', 'loadBalancer_ipAddressType' - The IP address type of the load balancer.
--
-- The possible values are @ipv4@ for IPv4 only, and @dualstack@ for IPv4
-- and IPv6.
--
-- 'location', 'loadBalancer_location' - The AWS Region where your load balancer was created (e.g.,
-- @us-east-2a@). Lightsail automatically creates your load balancer across
-- Availability Zones.
--
-- 'name', 'loadBalancer_name' - The name of the load balancer (e.g., @my-load-balancer@).
--
-- 'protocol', 'loadBalancer_protocol' - The protocol you have enabled for your load balancer. Valid values are
-- below.
--
-- You can\'t just have @HTTP_HTTPS@, but you can have just @HTTP@.
--
-- 'publicPorts', 'loadBalancer_publicPorts' - An array of public port settings for your load balancer. For HTTP, use
-- port 80. For HTTPS, use port 443.
--
-- 'resourceType', 'loadBalancer_resourceType' - The resource type (e.g., @LoadBalancer@.
--
-- 'state', 'loadBalancer_state' - The status of your load balancer. Valid values are below.
--
-- 'supportCode', 'loadBalancer_supportCode' - The support code. Include this code in your email to support when you
-- have questions about your Lightsail load balancer. This code enables our
-- support team to look up your Lightsail information more easily.
--
-- 'tags', 'loadBalancer_tags' - The tag keys and optional values for the resource. For more information
-- about tags in Lightsail, see the
-- <https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-tags Amazon Lightsail Developer Guide>.
--
-- 'tlsCertificateSummaries', 'loadBalancer_tlsCertificateSummaries' - An array of LoadBalancerTlsCertificateSummary objects that provide
-- additional information about the SSL\/TLS certificates. For example, if
-- @true@, the certificate is attached to the load balancer.
--
-- 'tlsPolicyName', 'loadBalancer_tlsPolicyName' - The name of the TLS security policy for the load balancer.
newLoadBalancer ::
  LoadBalancer
newLoadBalancer :: LoadBalancer
newLoadBalancer =
  LoadBalancer'
    { $sel:arn:LoadBalancer' :: Maybe Text
arn = forall a. Maybe a
Prelude.Nothing,
      $sel:configurationOptions:LoadBalancer' :: Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:LoadBalancer' :: Maybe POSIX
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:dnsName:LoadBalancer' :: Maybe Text
dnsName = forall a. Maybe a
Prelude.Nothing,
      $sel:healthCheckPath:LoadBalancer' :: Maybe Text
healthCheckPath = forall a. Maybe a
Prelude.Nothing,
      $sel:httpsRedirectionEnabled:LoadBalancer' :: Maybe Bool
httpsRedirectionEnabled = forall a. Maybe a
Prelude.Nothing,
      $sel:instanceHealthSummary:LoadBalancer' :: Maybe [InstanceHealthSummary]
instanceHealthSummary = forall a. Maybe a
Prelude.Nothing,
      $sel:instancePort:LoadBalancer' :: Maybe Int
instancePort = forall a. Maybe a
Prelude.Nothing,
      $sel:ipAddressType:LoadBalancer' :: Maybe IpAddressType
ipAddressType = forall a. Maybe a
Prelude.Nothing,
      $sel:location:LoadBalancer' :: Maybe ResourceLocation
location = forall a. Maybe a
Prelude.Nothing,
      $sel:name:LoadBalancer' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
      $sel:protocol:LoadBalancer' :: Maybe LoadBalancerProtocol
protocol = forall a. Maybe a
Prelude.Nothing,
      $sel:publicPorts:LoadBalancer' :: Maybe [Int]
publicPorts = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceType:LoadBalancer' :: Maybe ResourceType
resourceType = forall a. Maybe a
Prelude.Nothing,
      $sel:state:LoadBalancer' :: Maybe LoadBalancerState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:supportCode:LoadBalancer' :: Maybe Text
supportCode = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:LoadBalancer' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:tlsCertificateSummaries:LoadBalancer' :: Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries = forall a. Maybe a
Prelude.Nothing,
      $sel:tlsPolicyName:LoadBalancer' :: Maybe Text
tlsPolicyName = forall a. Maybe a
Prelude.Nothing
    }

-- | The Amazon Resource Name (ARN) of the load balancer.
loadBalancer_arn :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Text)
loadBalancer_arn :: Lens' LoadBalancer (Maybe Text)
loadBalancer_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Text
arn :: Maybe Text
$sel:arn:LoadBalancer' :: LoadBalancer -> Maybe Text
arn} -> Maybe Text
arn) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Text
a -> LoadBalancer
s {$sel:arn:LoadBalancer' :: Maybe Text
arn = Maybe Text
a} :: LoadBalancer)

-- | A string to string map of the configuration options for your load
-- balancer. Valid values are listed below.
loadBalancer_configurationOptions :: Lens.Lens' LoadBalancer (Prelude.Maybe (Prelude.HashMap LoadBalancerAttributeName Prelude.Text))
loadBalancer_configurationOptions :: Lens' LoadBalancer (Maybe (HashMap LoadBalancerAttributeName Text))
loadBalancer_configurationOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions :: Maybe (HashMap LoadBalancerAttributeName Text)
$sel:configurationOptions:LoadBalancer' :: LoadBalancer -> Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions} -> Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe (HashMap LoadBalancerAttributeName Text)
a -> LoadBalancer
s {$sel:configurationOptions:LoadBalancer' :: Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions = Maybe (HashMap LoadBalancerAttributeName Text)
a} :: LoadBalancer) 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 date when your load balancer was created.
loadBalancer_createdAt :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.UTCTime)
loadBalancer_createdAt :: Lens' LoadBalancer (Maybe UTCTime)
loadBalancer_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:LoadBalancer' :: LoadBalancer -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe POSIX
a -> LoadBalancer
s {$sel:createdAt:LoadBalancer' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: LoadBalancer) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The DNS name of your Lightsail load balancer.
loadBalancer_dnsName :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Text)
loadBalancer_dnsName :: Lens' LoadBalancer (Maybe Text)
loadBalancer_dnsName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Text
dnsName :: Maybe Text
$sel:dnsName:LoadBalancer' :: LoadBalancer -> Maybe Text
dnsName} -> Maybe Text
dnsName) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Text
a -> LoadBalancer
s {$sel:dnsName:LoadBalancer' :: Maybe Text
dnsName = Maybe Text
a} :: LoadBalancer)

-- | The path you specified to perform your health checks. If no path is
-- specified, the load balancer tries to make a request to the default
-- (root) page.
loadBalancer_healthCheckPath :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Text)
loadBalancer_healthCheckPath :: Lens' LoadBalancer (Maybe Text)
loadBalancer_healthCheckPath = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Text
healthCheckPath :: Maybe Text
$sel:healthCheckPath:LoadBalancer' :: LoadBalancer -> Maybe Text
healthCheckPath} -> Maybe Text
healthCheckPath) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Text
a -> LoadBalancer
s {$sel:healthCheckPath:LoadBalancer' :: Maybe Text
healthCheckPath = Maybe Text
a} :: LoadBalancer)

-- | A Boolean value that indicates whether HTTPS redirection is enabled for
-- the load balancer.
loadBalancer_httpsRedirectionEnabled :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Bool)
loadBalancer_httpsRedirectionEnabled :: Lens' LoadBalancer (Maybe Bool)
loadBalancer_httpsRedirectionEnabled = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Bool
httpsRedirectionEnabled :: Maybe Bool
$sel:httpsRedirectionEnabled:LoadBalancer' :: LoadBalancer -> Maybe Bool
httpsRedirectionEnabled} -> Maybe Bool
httpsRedirectionEnabled) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Bool
a -> LoadBalancer
s {$sel:httpsRedirectionEnabled:LoadBalancer' :: Maybe Bool
httpsRedirectionEnabled = Maybe Bool
a} :: LoadBalancer)

-- | An array of InstanceHealthSummary objects describing the health of the
-- load balancer.
loadBalancer_instanceHealthSummary :: Lens.Lens' LoadBalancer (Prelude.Maybe [InstanceHealthSummary])
loadBalancer_instanceHealthSummary :: Lens' LoadBalancer (Maybe [InstanceHealthSummary])
loadBalancer_instanceHealthSummary = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe [InstanceHealthSummary]
instanceHealthSummary :: Maybe [InstanceHealthSummary]
$sel:instanceHealthSummary:LoadBalancer' :: LoadBalancer -> Maybe [InstanceHealthSummary]
instanceHealthSummary} -> Maybe [InstanceHealthSummary]
instanceHealthSummary) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe [InstanceHealthSummary]
a -> LoadBalancer
s {$sel:instanceHealthSummary:LoadBalancer' :: Maybe [InstanceHealthSummary]
instanceHealthSummary = Maybe [InstanceHealthSummary]
a} :: LoadBalancer) 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 port where the load balancer will direct traffic to your Lightsail
-- instances. For HTTP traffic, it\'s port 80. For HTTPS traffic, it\'s
-- port 443.
loadBalancer_instancePort :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Int)
loadBalancer_instancePort :: Lens' LoadBalancer (Maybe Int)
loadBalancer_instancePort = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Int
instancePort :: Maybe Int
$sel:instancePort:LoadBalancer' :: LoadBalancer -> Maybe Int
instancePort} -> Maybe Int
instancePort) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Int
a -> LoadBalancer
s {$sel:instancePort:LoadBalancer' :: Maybe Int
instancePort = Maybe Int
a} :: LoadBalancer)

-- | The IP address type of the load balancer.
--
-- The possible values are @ipv4@ for IPv4 only, and @dualstack@ for IPv4
-- and IPv6.
loadBalancer_ipAddressType :: Lens.Lens' LoadBalancer (Prelude.Maybe IpAddressType)
loadBalancer_ipAddressType :: Lens' LoadBalancer (Maybe IpAddressType)
loadBalancer_ipAddressType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe IpAddressType
ipAddressType :: Maybe IpAddressType
$sel:ipAddressType:LoadBalancer' :: LoadBalancer -> Maybe IpAddressType
ipAddressType} -> Maybe IpAddressType
ipAddressType) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe IpAddressType
a -> LoadBalancer
s {$sel:ipAddressType:LoadBalancer' :: Maybe IpAddressType
ipAddressType = Maybe IpAddressType
a} :: LoadBalancer)

-- | The AWS Region where your load balancer was created (e.g.,
-- @us-east-2a@). Lightsail automatically creates your load balancer across
-- Availability Zones.
loadBalancer_location :: Lens.Lens' LoadBalancer (Prelude.Maybe ResourceLocation)
loadBalancer_location :: Lens' LoadBalancer (Maybe ResourceLocation)
loadBalancer_location = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe ResourceLocation
location :: Maybe ResourceLocation
$sel:location:LoadBalancer' :: LoadBalancer -> Maybe ResourceLocation
location} -> Maybe ResourceLocation
location) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe ResourceLocation
a -> LoadBalancer
s {$sel:location:LoadBalancer' :: Maybe ResourceLocation
location = Maybe ResourceLocation
a} :: LoadBalancer)

-- | The name of the load balancer (e.g., @my-load-balancer@).
loadBalancer_name :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Text)
loadBalancer_name :: Lens' LoadBalancer (Maybe Text)
loadBalancer_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Text
name :: Maybe Text
$sel:name:LoadBalancer' :: LoadBalancer -> Maybe Text
name} -> Maybe Text
name) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Text
a -> LoadBalancer
s {$sel:name:LoadBalancer' :: Maybe Text
name = Maybe Text
a} :: LoadBalancer)

-- | The protocol you have enabled for your load balancer. Valid values are
-- below.
--
-- You can\'t just have @HTTP_HTTPS@, but you can have just @HTTP@.
loadBalancer_protocol :: Lens.Lens' LoadBalancer (Prelude.Maybe LoadBalancerProtocol)
loadBalancer_protocol :: Lens' LoadBalancer (Maybe LoadBalancerProtocol)
loadBalancer_protocol = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe LoadBalancerProtocol
protocol :: Maybe LoadBalancerProtocol
$sel:protocol:LoadBalancer' :: LoadBalancer -> Maybe LoadBalancerProtocol
protocol} -> Maybe LoadBalancerProtocol
protocol) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe LoadBalancerProtocol
a -> LoadBalancer
s {$sel:protocol:LoadBalancer' :: Maybe LoadBalancerProtocol
protocol = Maybe LoadBalancerProtocol
a} :: LoadBalancer)

-- | An array of public port settings for your load balancer. For HTTP, use
-- port 80. For HTTPS, use port 443.
loadBalancer_publicPorts :: Lens.Lens' LoadBalancer (Prelude.Maybe [Prelude.Int])
loadBalancer_publicPorts :: Lens' LoadBalancer (Maybe [Int])
loadBalancer_publicPorts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe [Int]
publicPorts :: Maybe [Int]
$sel:publicPorts:LoadBalancer' :: LoadBalancer -> Maybe [Int]
publicPorts} -> Maybe [Int]
publicPorts) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe [Int]
a -> LoadBalancer
s {$sel:publicPorts:LoadBalancer' :: Maybe [Int]
publicPorts = Maybe [Int]
a} :: LoadBalancer) 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 resource type (e.g., @LoadBalancer@.
loadBalancer_resourceType :: Lens.Lens' LoadBalancer (Prelude.Maybe ResourceType)
loadBalancer_resourceType :: Lens' LoadBalancer (Maybe ResourceType)
loadBalancer_resourceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe ResourceType
resourceType :: Maybe ResourceType
$sel:resourceType:LoadBalancer' :: LoadBalancer -> Maybe ResourceType
resourceType} -> Maybe ResourceType
resourceType) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe ResourceType
a -> LoadBalancer
s {$sel:resourceType:LoadBalancer' :: Maybe ResourceType
resourceType = Maybe ResourceType
a} :: LoadBalancer)

-- | The status of your load balancer. Valid values are below.
loadBalancer_state :: Lens.Lens' LoadBalancer (Prelude.Maybe LoadBalancerState)
loadBalancer_state :: Lens' LoadBalancer (Maybe LoadBalancerState)
loadBalancer_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe LoadBalancerState
state :: Maybe LoadBalancerState
$sel:state:LoadBalancer' :: LoadBalancer -> Maybe LoadBalancerState
state} -> Maybe LoadBalancerState
state) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe LoadBalancerState
a -> LoadBalancer
s {$sel:state:LoadBalancer' :: Maybe LoadBalancerState
state = Maybe LoadBalancerState
a} :: LoadBalancer)

-- | The support code. Include this code in your email to support when you
-- have questions about your Lightsail load balancer. This code enables our
-- support team to look up your Lightsail information more easily.
loadBalancer_supportCode :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Text)
loadBalancer_supportCode :: Lens' LoadBalancer (Maybe Text)
loadBalancer_supportCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Text
supportCode :: Maybe Text
$sel:supportCode:LoadBalancer' :: LoadBalancer -> Maybe Text
supportCode} -> Maybe Text
supportCode) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Text
a -> LoadBalancer
s {$sel:supportCode:LoadBalancer' :: Maybe Text
supportCode = Maybe Text
a} :: LoadBalancer)

-- | The tag keys and optional values for the resource. For more information
-- about tags in Lightsail, see the
-- <https://lightsail.aws.amazon.com/ls/docs/en_us/articles/amazon-lightsail-tags Amazon Lightsail Developer Guide>.
loadBalancer_tags :: Lens.Lens' LoadBalancer (Prelude.Maybe [Tag])
loadBalancer_tags :: Lens' LoadBalancer (Maybe [Tag])
loadBalancer_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:LoadBalancer' :: LoadBalancer -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe [Tag]
a -> LoadBalancer
s {$sel:tags:LoadBalancer' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: LoadBalancer) 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

-- | An array of LoadBalancerTlsCertificateSummary objects that provide
-- additional information about the SSL\/TLS certificates. For example, if
-- @true@, the certificate is attached to the load balancer.
loadBalancer_tlsCertificateSummaries :: Lens.Lens' LoadBalancer (Prelude.Maybe [LoadBalancerTlsCertificateSummary])
loadBalancer_tlsCertificateSummaries :: Lens' LoadBalancer (Maybe [LoadBalancerTlsCertificateSummary])
loadBalancer_tlsCertificateSummaries = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries :: Maybe [LoadBalancerTlsCertificateSummary]
$sel:tlsCertificateSummaries:LoadBalancer' :: LoadBalancer -> Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries} -> Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe [LoadBalancerTlsCertificateSummary]
a -> LoadBalancer
s {$sel:tlsCertificateSummaries:LoadBalancer' :: Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries = Maybe [LoadBalancerTlsCertificateSummary]
a} :: LoadBalancer) 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 TLS security policy for the load balancer.
loadBalancer_tlsPolicyName :: Lens.Lens' LoadBalancer (Prelude.Maybe Prelude.Text)
loadBalancer_tlsPolicyName :: Lens' LoadBalancer (Maybe Text)
loadBalancer_tlsPolicyName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LoadBalancer' {Maybe Text
tlsPolicyName :: Maybe Text
$sel:tlsPolicyName:LoadBalancer' :: LoadBalancer -> Maybe Text
tlsPolicyName} -> Maybe Text
tlsPolicyName) (\s :: LoadBalancer
s@LoadBalancer' {} Maybe Text
a -> LoadBalancer
s {$sel:tlsPolicyName:LoadBalancer' :: Maybe Text
tlsPolicyName = Maybe Text
a} :: LoadBalancer)

instance Data.FromJSON LoadBalancer where
  parseJSON :: Value -> Parser LoadBalancer
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"LoadBalancer"
      ( \Object
x ->
          Maybe Text
-> Maybe (HashMap LoadBalancerAttributeName Text)
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe [InstanceHealthSummary]
-> Maybe Int
-> Maybe IpAddressType
-> Maybe ResourceLocation
-> Maybe Text
-> Maybe LoadBalancerProtocol
-> Maybe [Int]
-> Maybe ResourceType
-> Maybe LoadBalancerState
-> Maybe Text
-> Maybe [Tag]
-> Maybe [LoadBalancerTlsCertificateSummary]
-> Maybe Text
-> LoadBalancer
LoadBalancer'
            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
"arn")
            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
"configurationOptions"
                            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
"createdAt")
            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
"dnsName")
            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
"healthCheckPath")
            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
"httpsRedirectionEnabled")
            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
"instanceHealthSummary"
                            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
"instancePort")
            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
"ipAddressType")
            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
"location")
            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
"name")
            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
"protocol")
            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
"publicPorts" 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
"resourceType")
            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
"state")
            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
"supportCode")
            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
"tags" 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
"tlsCertificateSummaries"
                            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
"tlsPolicyName")
      )

instance Prelude.Hashable LoadBalancer where
  hashWithSalt :: Int -> LoadBalancer -> Int
hashWithSalt Int
_salt LoadBalancer' {Maybe Bool
Maybe Int
Maybe [Int]
Maybe [InstanceHealthSummary]
Maybe [LoadBalancerTlsCertificateSummary]
Maybe [Tag]
Maybe Text
Maybe (HashMap LoadBalancerAttributeName Text)
Maybe POSIX
Maybe IpAddressType
Maybe LoadBalancerProtocol
Maybe LoadBalancerState
Maybe ResourceLocation
Maybe ResourceType
tlsPolicyName :: Maybe Text
tlsCertificateSummaries :: Maybe [LoadBalancerTlsCertificateSummary]
tags :: Maybe [Tag]
supportCode :: Maybe Text
state :: Maybe LoadBalancerState
resourceType :: Maybe ResourceType
publicPorts :: Maybe [Int]
protocol :: Maybe LoadBalancerProtocol
name :: Maybe Text
location :: Maybe ResourceLocation
ipAddressType :: Maybe IpAddressType
instancePort :: Maybe Int
instanceHealthSummary :: Maybe [InstanceHealthSummary]
httpsRedirectionEnabled :: Maybe Bool
healthCheckPath :: Maybe Text
dnsName :: Maybe Text
createdAt :: Maybe POSIX
configurationOptions :: Maybe (HashMap LoadBalancerAttributeName Text)
arn :: Maybe Text
$sel:tlsPolicyName:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:tlsCertificateSummaries:LoadBalancer' :: LoadBalancer -> Maybe [LoadBalancerTlsCertificateSummary]
$sel:tags:LoadBalancer' :: LoadBalancer -> Maybe [Tag]
$sel:supportCode:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:state:LoadBalancer' :: LoadBalancer -> Maybe LoadBalancerState
$sel:resourceType:LoadBalancer' :: LoadBalancer -> Maybe ResourceType
$sel:publicPorts:LoadBalancer' :: LoadBalancer -> Maybe [Int]
$sel:protocol:LoadBalancer' :: LoadBalancer -> Maybe LoadBalancerProtocol
$sel:name:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:location:LoadBalancer' :: LoadBalancer -> Maybe ResourceLocation
$sel:ipAddressType:LoadBalancer' :: LoadBalancer -> Maybe IpAddressType
$sel:instancePort:LoadBalancer' :: LoadBalancer -> Maybe Int
$sel:instanceHealthSummary:LoadBalancer' :: LoadBalancer -> Maybe [InstanceHealthSummary]
$sel:httpsRedirectionEnabled:LoadBalancer' :: LoadBalancer -> Maybe Bool
$sel:healthCheckPath:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:dnsName:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:createdAt:LoadBalancer' :: LoadBalancer -> Maybe POSIX
$sel:configurationOptions:LoadBalancer' :: LoadBalancer -> Maybe (HashMap LoadBalancerAttributeName Text)
$sel:arn:LoadBalancer' :: LoadBalancer -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
arn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
createdAt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dnsName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
healthCheckPath
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
httpsRedirectionEnabled
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [InstanceHealthSummary]
instanceHealthSummary
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
instancePort
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe IpAddressType
ipAddressType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResourceLocation
location
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LoadBalancerProtocol
protocol
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Int]
publicPorts
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResourceType
resourceType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LoadBalancerState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
supportCode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
tlsPolicyName

instance Prelude.NFData LoadBalancer where
  rnf :: LoadBalancer -> ()
rnf LoadBalancer' {Maybe Bool
Maybe Int
Maybe [Int]
Maybe [InstanceHealthSummary]
Maybe [LoadBalancerTlsCertificateSummary]
Maybe [Tag]
Maybe Text
Maybe (HashMap LoadBalancerAttributeName Text)
Maybe POSIX
Maybe IpAddressType
Maybe LoadBalancerProtocol
Maybe LoadBalancerState
Maybe ResourceLocation
Maybe ResourceType
tlsPolicyName :: Maybe Text
tlsCertificateSummaries :: Maybe [LoadBalancerTlsCertificateSummary]
tags :: Maybe [Tag]
supportCode :: Maybe Text
state :: Maybe LoadBalancerState
resourceType :: Maybe ResourceType
publicPorts :: Maybe [Int]
protocol :: Maybe LoadBalancerProtocol
name :: Maybe Text
location :: Maybe ResourceLocation
ipAddressType :: Maybe IpAddressType
instancePort :: Maybe Int
instanceHealthSummary :: Maybe [InstanceHealthSummary]
httpsRedirectionEnabled :: Maybe Bool
healthCheckPath :: Maybe Text
dnsName :: Maybe Text
createdAt :: Maybe POSIX
configurationOptions :: Maybe (HashMap LoadBalancerAttributeName Text)
arn :: Maybe Text
$sel:tlsPolicyName:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:tlsCertificateSummaries:LoadBalancer' :: LoadBalancer -> Maybe [LoadBalancerTlsCertificateSummary]
$sel:tags:LoadBalancer' :: LoadBalancer -> Maybe [Tag]
$sel:supportCode:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:state:LoadBalancer' :: LoadBalancer -> Maybe LoadBalancerState
$sel:resourceType:LoadBalancer' :: LoadBalancer -> Maybe ResourceType
$sel:publicPorts:LoadBalancer' :: LoadBalancer -> Maybe [Int]
$sel:protocol:LoadBalancer' :: LoadBalancer -> Maybe LoadBalancerProtocol
$sel:name:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:location:LoadBalancer' :: LoadBalancer -> Maybe ResourceLocation
$sel:ipAddressType:LoadBalancer' :: LoadBalancer -> Maybe IpAddressType
$sel:instancePort:LoadBalancer' :: LoadBalancer -> Maybe Int
$sel:instanceHealthSummary:LoadBalancer' :: LoadBalancer -> Maybe [InstanceHealthSummary]
$sel:httpsRedirectionEnabled:LoadBalancer' :: LoadBalancer -> Maybe Bool
$sel:healthCheckPath:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:dnsName:LoadBalancer' :: LoadBalancer -> Maybe Text
$sel:createdAt:LoadBalancer' :: LoadBalancer -> Maybe POSIX
$sel:configurationOptions:LoadBalancer' :: LoadBalancer -> Maybe (HashMap LoadBalancerAttributeName Text)
$sel:arn:LoadBalancer' :: LoadBalancer -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap LoadBalancerAttributeName Text)
configurationOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dnsName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
healthCheckPath
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
httpsRedirectionEnabled
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [InstanceHealthSummary]
instanceHealthSummary
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
instancePort
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe IpAddressType
ipAddressType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceLocation
location
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LoadBalancerProtocol
protocol
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Int]
publicPorts
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceType
resourceType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LoadBalancerState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
supportCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe [LoadBalancerTlsCertificateSummary]
tlsCertificateSummaries
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
tlsPolicyName