{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.ELB.CreateLoadBalancerPolicy
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a policy with the specified attributes for the specified load
-- balancer.
--
-- Policies are settings that are saved for your load balancer and that can
-- be applied to the listener or the application server, depending on the
-- policy type.
module Amazonka.ELB.CreateLoadBalancerPolicy
  ( -- * Creating a Request
    CreateLoadBalancerPolicy (..),
    newCreateLoadBalancerPolicy,

    -- * Request Lenses
    createLoadBalancerPolicy_policyAttributes,
    createLoadBalancerPolicy_loadBalancerName,
    createLoadBalancerPolicy_policyName,
    createLoadBalancerPolicy_policyTypeName,

    -- * Destructuring the Response
    CreateLoadBalancerPolicyResponse (..),
    newCreateLoadBalancerPolicyResponse,

    -- * Response Lenses
    createLoadBalancerPolicyResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.ELB.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Contains the parameters for CreateLoadBalancerPolicy.
--
-- /See:/ 'newCreateLoadBalancerPolicy' smart constructor.
data CreateLoadBalancerPolicy = CreateLoadBalancerPolicy'
  { -- | The policy attributes.
    CreateLoadBalancerPolicy -> Maybe [PolicyAttribute]
policyAttributes :: Prelude.Maybe [PolicyAttribute],
    -- | The name of the load balancer.
    CreateLoadBalancerPolicy -> Text
loadBalancerName :: Prelude.Text,
    -- | The name of the load balancer policy to be created. This name must be
    -- unique within the set of policies for this load balancer.
    CreateLoadBalancerPolicy -> Text
policyName :: Prelude.Text,
    -- | The name of the base policy type. To get the list of policy types, use
    -- DescribeLoadBalancerPolicyTypes.
    CreateLoadBalancerPolicy -> Text
policyTypeName :: Prelude.Text
  }
  deriving (CreateLoadBalancerPolicy -> CreateLoadBalancerPolicy -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateLoadBalancerPolicy -> CreateLoadBalancerPolicy -> Bool
$c/= :: CreateLoadBalancerPolicy -> CreateLoadBalancerPolicy -> Bool
== :: CreateLoadBalancerPolicy -> CreateLoadBalancerPolicy -> Bool
$c== :: CreateLoadBalancerPolicy -> CreateLoadBalancerPolicy -> Bool
Prelude.Eq, ReadPrec [CreateLoadBalancerPolicy]
ReadPrec CreateLoadBalancerPolicy
Int -> ReadS CreateLoadBalancerPolicy
ReadS [CreateLoadBalancerPolicy]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateLoadBalancerPolicy]
$creadListPrec :: ReadPrec [CreateLoadBalancerPolicy]
readPrec :: ReadPrec CreateLoadBalancerPolicy
$creadPrec :: ReadPrec CreateLoadBalancerPolicy
readList :: ReadS [CreateLoadBalancerPolicy]
$creadList :: ReadS [CreateLoadBalancerPolicy]
readsPrec :: Int -> ReadS CreateLoadBalancerPolicy
$creadsPrec :: Int -> ReadS CreateLoadBalancerPolicy
Prelude.Read, Int -> CreateLoadBalancerPolicy -> ShowS
[CreateLoadBalancerPolicy] -> ShowS
CreateLoadBalancerPolicy -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateLoadBalancerPolicy] -> ShowS
$cshowList :: [CreateLoadBalancerPolicy] -> ShowS
show :: CreateLoadBalancerPolicy -> String
$cshow :: CreateLoadBalancerPolicy -> String
showsPrec :: Int -> CreateLoadBalancerPolicy -> ShowS
$cshowsPrec :: Int -> CreateLoadBalancerPolicy -> ShowS
Prelude.Show, forall x.
Rep CreateLoadBalancerPolicy x -> CreateLoadBalancerPolicy
forall x.
CreateLoadBalancerPolicy -> Rep CreateLoadBalancerPolicy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateLoadBalancerPolicy x -> CreateLoadBalancerPolicy
$cfrom :: forall x.
CreateLoadBalancerPolicy -> Rep CreateLoadBalancerPolicy x
Prelude.Generic)

-- |
-- Create a value of 'CreateLoadBalancerPolicy' 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:
--
-- 'policyAttributes', 'createLoadBalancerPolicy_policyAttributes' - The policy attributes.
--
-- 'loadBalancerName', 'createLoadBalancerPolicy_loadBalancerName' - The name of the load balancer.
--
-- 'policyName', 'createLoadBalancerPolicy_policyName' - The name of the load balancer policy to be created. This name must be
-- unique within the set of policies for this load balancer.
--
-- 'policyTypeName', 'createLoadBalancerPolicy_policyTypeName' - The name of the base policy type. To get the list of policy types, use
-- DescribeLoadBalancerPolicyTypes.
newCreateLoadBalancerPolicy ::
  -- | 'loadBalancerName'
  Prelude.Text ->
  -- | 'policyName'
  Prelude.Text ->
  -- | 'policyTypeName'
  Prelude.Text ->
  CreateLoadBalancerPolicy
newCreateLoadBalancerPolicy :: Text -> Text -> Text -> CreateLoadBalancerPolicy
newCreateLoadBalancerPolicy
  Text
pLoadBalancerName_
  Text
pPolicyName_
  Text
pPolicyTypeName_ =
    CreateLoadBalancerPolicy'
      { $sel:policyAttributes:CreateLoadBalancerPolicy' :: Maybe [PolicyAttribute]
policyAttributes =
          forall a. Maybe a
Prelude.Nothing,
        $sel:loadBalancerName:CreateLoadBalancerPolicy' :: Text
loadBalancerName = Text
pLoadBalancerName_,
        $sel:policyName:CreateLoadBalancerPolicy' :: Text
policyName = Text
pPolicyName_,
        $sel:policyTypeName:CreateLoadBalancerPolicy' :: Text
policyTypeName = Text
pPolicyTypeName_
      }

-- | The policy attributes.
createLoadBalancerPolicy_policyAttributes :: Lens.Lens' CreateLoadBalancerPolicy (Prelude.Maybe [PolicyAttribute])
createLoadBalancerPolicy_policyAttributes :: Lens' CreateLoadBalancerPolicy (Maybe [PolicyAttribute])
createLoadBalancerPolicy_policyAttributes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLoadBalancerPolicy' {Maybe [PolicyAttribute]
policyAttributes :: Maybe [PolicyAttribute]
$sel:policyAttributes:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Maybe [PolicyAttribute]
policyAttributes} -> Maybe [PolicyAttribute]
policyAttributes) (\s :: CreateLoadBalancerPolicy
s@CreateLoadBalancerPolicy' {} Maybe [PolicyAttribute]
a -> CreateLoadBalancerPolicy
s {$sel:policyAttributes:CreateLoadBalancerPolicy' :: Maybe [PolicyAttribute]
policyAttributes = Maybe [PolicyAttribute]
a} :: CreateLoadBalancerPolicy) 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 load balancer.
createLoadBalancerPolicy_loadBalancerName :: Lens.Lens' CreateLoadBalancerPolicy Prelude.Text
createLoadBalancerPolicy_loadBalancerName :: Lens' CreateLoadBalancerPolicy Text
createLoadBalancerPolicy_loadBalancerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLoadBalancerPolicy' {Text
loadBalancerName :: Text
$sel:loadBalancerName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
loadBalancerName} -> Text
loadBalancerName) (\s :: CreateLoadBalancerPolicy
s@CreateLoadBalancerPolicy' {} Text
a -> CreateLoadBalancerPolicy
s {$sel:loadBalancerName:CreateLoadBalancerPolicy' :: Text
loadBalancerName = Text
a} :: CreateLoadBalancerPolicy)

-- | The name of the load balancer policy to be created. This name must be
-- unique within the set of policies for this load balancer.
createLoadBalancerPolicy_policyName :: Lens.Lens' CreateLoadBalancerPolicy Prelude.Text
createLoadBalancerPolicy_policyName :: Lens' CreateLoadBalancerPolicy Text
createLoadBalancerPolicy_policyName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLoadBalancerPolicy' {Text
policyName :: Text
$sel:policyName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
policyName} -> Text
policyName) (\s :: CreateLoadBalancerPolicy
s@CreateLoadBalancerPolicy' {} Text
a -> CreateLoadBalancerPolicy
s {$sel:policyName:CreateLoadBalancerPolicy' :: Text
policyName = Text
a} :: CreateLoadBalancerPolicy)

-- | The name of the base policy type. To get the list of policy types, use
-- DescribeLoadBalancerPolicyTypes.
createLoadBalancerPolicy_policyTypeName :: Lens.Lens' CreateLoadBalancerPolicy Prelude.Text
createLoadBalancerPolicy_policyTypeName :: Lens' CreateLoadBalancerPolicy Text
createLoadBalancerPolicy_policyTypeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateLoadBalancerPolicy' {Text
policyTypeName :: Text
$sel:policyTypeName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
policyTypeName} -> Text
policyTypeName) (\s :: CreateLoadBalancerPolicy
s@CreateLoadBalancerPolicy' {} Text
a -> CreateLoadBalancerPolicy
s {$sel:policyTypeName:CreateLoadBalancerPolicy' :: Text
policyTypeName = Text
a} :: CreateLoadBalancerPolicy)

instance Core.AWSRequest CreateLoadBalancerPolicy where
  type
    AWSResponse CreateLoadBalancerPolicy =
      CreateLoadBalancerPolicyResponse
  request :: (Service -> Service)
-> CreateLoadBalancerPolicy -> Request CreateLoadBalancerPolicy
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateLoadBalancerPolicy
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateLoadBalancerPolicy)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"CreateLoadBalancerPolicyResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Int -> CreateLoadBalancerPolicyResponse
CreateLoadBalancerPolicyResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable CreateLoadBalancerPolicy where
  hashWithSalt :: Int -> CreateLoadBalancerPolicy -> Int
hashWithSalt Int
_salt CreateLoadBalancerPolicy' {Maybe [PolicyAttribute]
Text
policyTypeName :: Text
policyName :: Text
loadBalancerName :: Text
policyAttributes :: Maybe [PolicyAttribute]
$sel:policyTypeName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:policyName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:loadBalancerName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:policyAttributes:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Maybe [PolicyAttribute]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [PolicyAttribute]
policyAttributes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
loadBalancerName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
policyName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
policyTypeName

instance Prelude.NFData CreateLoadBalancerPolicy where
  rnf :: CreateLoadBalancerPolicy -> ()
rnf CreateLoadBalancerPolicy' {Maybe [PolicyAttribute]
Text
policyTypeName :: Text
policyName :: Text
loadBalancerName :: Text
policyAttributes :: Maybe [PolicyAttribute]
$sel:policyTypeName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:policyName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:loadBalancerName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:policyAttributes:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Maybe [PolicyAttribute]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [PolicyAttribute]
policyAttributes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
loadBalancerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
policyName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
policyTypeName

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

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

instance Data.ToQuery CreateLoadBalancerPolicy where
  toQuery :: CreateLoadBalancerPolicy -> QueryString
toQuery CreateLoadBalancerPolicy' {Maybe [PolicyAttribute]
Text
policyTypeName :: Text
policyName :: Text
loadBalancerName :: Text
policyAttributes :: Maybe [PolicyAttribute]
$sel:policyTypeName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:policyName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:loadBalancerName:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Text
$sel:policyAttributes:CreateLoadBalancerPolicy' :: CreateLoadBalancerPolicy -> Maybe [PolicyAttribute]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"CreateLoadBalancerPolicy" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2012-06-01" :: Prelude.ByteString),
        ByteString
"PolicyAttributes"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member"
                forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [PolicyAttribute]
policyAttributes
            ),
        ByteString
"LoadBalancerName" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
loadBalancerName,
        ByteString
"PolicyName" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
policyName,
        ByteString
"PolicyTypeName" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
policyTypeName
      ]

-- | Contains the output of CreateLoadBalancerPolicy.
--
-- /See:/ 'newCreateLoadBalancerPolicyResponse' smart constructor.
data CreateLoadBalancerPolicyResponse = CreateLoadBalancerPolicyResponse'
  { -- | The response's http status code.
    CreateLoadBalancerPolicyResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateLoadBalancerPolicyResponse
-> CreateLoadBalancerPolicyResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateLoadBalancerPolicyResponse
-> CreateLoadBalancerPolicyResponse -> Bool
$c/= :: CreateLoadBalancerPolicyResponse
-> CreateLoadBalancerPolicyResponse -> Bool
== :: CreateLoadBalancerPolicyResponse
-> CreateLoadBalancerPolicyResponse -> Bool
$c== :: CreateLoadBalancerPolicyResponse
-> CreateLoadBalancerPolicyResponse -> Bool
Prelude.Eq, ReadPrec [CreateLoadBalancerPolicyResponse]
ReadPrec CreateLoadBalancerPolicyResponse
Int -> ReadS CreateLoadBalancerPolicyResponse
ReadS [CreateLoadBalancerPolicyResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateLoadBalancerPolicyResponse]
$creadListPrec :: ReadPrec [CreateLoadBalancerPolicyResponse]
readPrec :: ReadPrec CreateLoadBalancerPolicyResponse
$creadPrec :: ReadPrec CreateLoadBalancerPolicyResponse
readList :: ReadS [CreateLoadBalancerPolicyResponse]
$creadList :: ReadS [CreateLoadBalancerPolicyResponse]
readsPrec :: Int -> ReadS CreateLoadBalancerPolicyResponse
$creadsPrec :: Int -> ReadS CreateLoadBalancerPolicyResponse
Prelude.Read, Int -> CreateLoadBalancerPolicyResponse -> ShowS
[CreateLoadBalancerPolicyResponse] -> ShowS
CreateLoadBalancerPolicyResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateLoadBalancerPolicyResponse] -> ShowS
$cshowList :: [CreateLoadBalancerPolicyResponse] -> ShowS
show :: CreateLoadBalancerPolicyResponse -> String
$cshow :: CreateLoadBalancerPolicyResponse -> String
showsPrec :: Int -> CreateLoadBalancerPolicyResponse -> ShowS
$cshowsPrec :: Int -> CreateLoadBalancerPolicyResponse -> ShowS
Prelude.Show, forall x.
Rep CreateLoadBalancerPolicyResponse x
-> CreateLoadBalancerPolicyResponse
forall x.
CreateLoadBalancerPolicyResponse
-> Rep CreateLoadBalancerPolicyResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateLoadBalancerPolicyResponse x
-> CreateLoadBalancerPolicyResponse
$cfrom :: forall x.
CreateLoadBalancerPolicyResponse
-> Rep CreateLoadBalancerPolicyResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateLoadBalancerPolicyResponse' 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:
--
-- 'httpStatus', 'createLoadBalancerPolicyResponse_httpStatus' - The response's http status code.
newCreateLoadBalancerPolicyResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateLoadBalancerPolicyResponse
newCreateLoadBalancerPolicyResponse :: Int -> CreateLoadBalancerPolicyResponse
newCreateLoadBalancerPolicyResponse Int
pHttpStatus_ =
  CreateLoadBalancerPolicyResponse'
    { $sel:httpStatus:CreateLoadBalancerPolicyResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance
  Prelude.NFData
    CreateLoadBalancerPolicyResponse
  where
  rnf :: CreateLoadBalancerPolicyResponse -> ()
rnf CreateLoadBalancerPolicyResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateLoadBalancerPolicyResponse' :: CreateLoadBalancerPolicyResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus