{-# 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.OpsWorks.SetLoadBasedAutoScaling
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Specify the load-based auto scaling configuration for a specified layer.
-- For more information, see
-- <https://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-autoscaling.html Managing Load with Time-based and Load-based Instances>.
--
-- To use load-based auto scaling, you must create a set of load-based auto
-- scaling instances. Load-based auto scaling operates only on the
-- instances from that set, so you must ensure that you have created enough
-- instances to handle the maximum anticipated load.
--
-- __Required Permissions__: To use this action, an IAM user must have a
-- Manage permissions level for the stack, or an attached policy that
-- explicitly grants permissions. For more information on user permissions,
-- see
-- <https://docs.aws.amazon.com/opsworks/latest/userguide/opsworks-security-users.html Managing User Permissions>.
module Amazonka.OpsWorks.SetLoadBasedAutoScaling
  ( -- * Creating a Request
    SetLoadBasedAutoScaling (..),
    newSetLoadBasedAutoScaling,

    -- * Request Lenses
    setLoadBasedAutoScaling_upScaling,
    setLoadBasedAutoScaling_enable,
    setLoadBasedAutoScaling_downScaling,
    setLoadBasedAutoScaling_layerId,

    -- * Destructuring the Response
    SetLoadBasedAutoScalingResponse (..),
    newSetLoadBasedAutoScalingResponse,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.OpsWorks.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newSetLoadBasedAutoScaling' smart constructor.
data SetLoadBasedAutoScaling = SetLoadBasedAutoScaling'
  { -- | An @AutoScalingThresholds@ object with the upscaling threshold
    -- configuration. If the load exceeds these thresholds for a specified
    -- amount of time, AWS OpsWorks Stacks starts a specified number of
    -- instances.
    SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds
upScaling :: Prelude.Maybe AutoScalingThresholds,
    -- | Enables load-based auto scaling for the layer.
    SetLoadBasedAutoScaling -> Maybe Bool
enable :: Prelude.Maybe Prelude.Bool,
    -- | An @AutoScalingThresholds@ object with the downscaling threshold
    -- configuration. If the load falls below these thresholds for a specified
    -- amount of time, AWS OpsWorks Stacks stops a specified number of
    -- instances.
    SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds
downScaling :: Prelude.Maybe AutoScalingThresholds,
    -- | The layer ID.
    SetLoadBasedAutoScaling -> Text
layerId :: Prelude.Text
  }
  deriving (SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool
(SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool)
-> (SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool)
-> Eq SetLoadBasedAutoScaling
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool
$c/= :: SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool
== :: SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool
$c== :: SetLoadBasedAutoScaling -> SetLoadBasedAutoScaling -> Bool
Prelude.Eq, ReadPrec [SetLoadBasedAutoScaling]
ReadPrec SetLoadBasedAutoScaling
Int -> ReadS SetLoadBasedAutoScaling
ReadS [SetLoadBasedAutoScaling]
(Int -> ReadS SetLoadBasedAutoScaling)
-> ReadS [SetLoadBasedAutoScaling]
-> ReadPrec SetLoadBasedAutoScaling
-> ReadPrec [SetLoadBasedAutoScaling]
-> Read SetLoadBasedAutoScaling
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SetLoadBasedAutoScaling]
$creadListPrec :: ReadPrec [SetLoadBasedAutoScaling]
readPrec :: ReadPrec SetLoadBasedAutoScaling
$creadPrec :: ReadPrec SetLoadBasedAutoScaling
readList :: ReadS [SetLoadBasedAutoScaling]
$creadList :: ReadS [SetLoadBasedAutoScaling]
readsPrec :: Int -> ReadS SetLoadBasedAutoScaling
$creadsPrec :: Int -> ReadS SetLoadBasedAutoScaling
Prelude.Read, Int -> SetLoadBasedAutoScaling -> ShowS
[SetLoadBasedAutoScaling] -> ShowS
SetLoadBasedAutoScaling -> String
(Int -> SetLoadBasedAutoScaling -> ShowS)
-> (SetLoadBasedAutoScaling -> String)
-> ([SetLoadBasedAutoScaling] -> ShowS)
-> Show SetLoadBasedAutoScaling
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetLoadBasedAutoScaling] -> ShowS
$cshowList :: [SetLoadBasedAutoScaling] -> ShowS
show :: SetLoadBasedAutoScaling -> String
$cshow :: SetLoadBasedAutoScaling -> String
showsPrec :: Int -> SetLoadBasedAutoScaling -> ShowS
$cshowsPrec :: Int -> SetLoadBasedAutoScaling -> ShowS
Prelude.Show, (forall x.
 SetLoadBasedAutoScaling -> Rep SetLoadBasedAutoScaling x)
-> (forall x.
    Rep SetLoadBasedAutoScaling x -> SetLoadBasedAutoScaling)
-> Generic SetLoadBasedAutoScaling
forall x. Rep SetLoadBasedAutoScaling x -> SetLoadBasedAutoScaling
forall x. SetLoadBasedAutoScaling -> Rep SetLoadBasedAutoScaling x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SetLoadBasedAutoScaling x -> SetLoadBasedAutoScaling
$cfrom :: forall x. SetLoadBasedAutoScaling -> Rep SetLoadBasedAutoScaling x
Prelude.Generic)

-- |
-- Create a value of 'SetLoadBasedAutoScaling' 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:
--
-- 'upScaling', 'setLoadBasedAutoScaling_upScaling' - An @AutoScalingThresholds@ object with the upscaling threshold
-- configuration. If the load exceeds these thresholds for a specified
-- amount of time, AWS OpsWorks Stacks starts a specified number of
-- instances.
--
-- 'enable', 'setLoadBasedAutoScaling_enable' - Enables load-based auto scaling for the layer.
--
-- 'downScaling', 'setLoadBasedAutoScaling_downScaling' - An @AutoScalingThresholds@ object with the downscaling threshold
-- configuration. If the load falls below these thresholds for a specified
-- amount of time, AWS OpsWorks Stacks stops a specified number of
-- instances.
--
-- 'layerId', 'setLoadBasedAutoScaling_layerId' - The layer ID.
newSetLoadBasedAutoScaling ::
  -- | 'layerId'
  Prelude.Text ->
  SetLoadBasedAutoScaling
newSetLoadBasedAutoScaling :: Text -> SetLoadBasedAutoScaling
newSetLoadBasedAutoScaling Text
pLayerId_ =
  SetLoadBasedAutoScaling' :: Maybe AutoScalingThresholds
-> Maybe Bool
-> Maybe AutoScalingThresholds
-> Text
-> SetLoadBasedAutoScaling
SetLoadBasedAutoScaling'
    { $sel:upScaling:SetLoadBasedAutoScaling' :: Maybe AutoScalingThresholds
upScaling =
        Maybe AutoScalingThresholds
forall a. Maybe a
Prelude.Nothing,
      $sel:enable:SetLoadBasedAutoScaling' :: Maybe Bool
enable = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:downScaling:SetLoadBasedAutoScaling' :: Maybe AutoScalingThresholds
downScaling = Maybe AutoScalingThresholds
forall a. Maybe a
Prelude.Nothing,
      $sel:layerId:SetLoadBasedAutoScaling' :: Text
layerId = Text
pLayerId_
    }

-- | An @AutoScalingThresholds@ object with the upscaling threshold
-- configuration. If the load exceeds these thresholds for a specified
-- amount of time, AWS OpsWorks Stacks starts a specified number of
-- instances.
setLoadBasedAutoScaling_upScaling :: Lens.Lens' SetLoadBasedAutoScaling (Prelude.Maybe AutoScalingThresholds)
setLoadBasedAutoScaling_upScaling :: (Maybe AutoScalingThresholds -> f (Maybe AutoScalingThresholds))
-> SetLoadBasedAutoScaling -> f SetLoadBasedAutoScaling
setLoadBasedAutoScaling_upScaling = (SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds)
-> (SetLoadBasedAutoScaling
    -> Maybe AutoScalingThresholds -> SetLoadBasedAutoScaling)
-> Lens
     SetLoadBasedAutoScaling
     SetLoadBasedAutoScaling
     (Maybe AutoScalingThresholds)
     (Maybe AutoScalingThresholds)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetLoadBasedAutoScaling' {Maybe AutoScalingThresholds
upScaling :: Maybe AutoScalingThresholds
$sel:upScaling:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds
upScaling} -> Maybe AutoScalingThresholds
upScaling) (\s :: SetLoadBasedAutoScaling
s@SetLoadBasedAutoScaling' {} Maybe AutoScalingThresholds
a -> SetLoadBasedAutoScaling
s {$sel:upScaling:SetLoadBasedAutoScaling' :: Maybe AutoScalingThresholds
upScaling = Maybe AutoScalingThresholds
a} :: SetLoadBasedAutoScaling)

-- | Enables load-based auto scaling for the layer.
setLoadBasedAutoScaling_enable :: Lens.Lens' SetLoadBasedAutoScaling (Prelude.Maybe Prelude.Bool)
setLoadBasedAutoScaling_enable :: (Maybe Bool -> f (Maybe Bool))
-> SetLoadBasedAutoScaling -> f SetLoadBasedAutoScaling
setLoadBasedAutoScaling_enable = (SetLoadBasedAutoScaling -> Maybe Bool)
-> (SetLoadBasedAutoScaling
    -> Maybe Bool -> SetLoadBasedAutoScaling)
-> Lens
     SetLoadBasedAutoScaling
     SetLoadBasedAutoScaling
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetLoadBasedAutoScaling' {Maybe Bool
enable :: Maybe Bool
$sel:enable:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Maybe Bool
enable} -> Maybe Bool
enable) (\s :: SetLoadBasedAutoScaling
s@SetLoadBasedAutoScaling' {} Maybe Bool
a -> SetLoadBasedAutoScaling
s {$sel:enable:SetLoadBasedAutoScaling' :: Maybe Bool
enable = Maybe Bool
a} :: SetLoadBasedAutoScaling)

-- | An @AutoScalingThresholds@ object with the downscaling threshold
-- configuration. If the load falls below these thresholds for a specified
-- amount of time, AWS OpsWorks Stacks stops a specified number of
-- instances.
setLoadBasedAutoScaling_downScaling :: Lens.Lens' SetLoadBasedAutoScaling (Prelude.Maybe AutoScalingThresholds)
setLoadBasedAutoScaling_downScaling :: (Maybe AutoScalingThresholds -> f (Maybe AutoScalingThresholds))
-> SetLoadBasedAutoScaling -> f SetLoadBasedAutoScaling
setLoadBasedAutoScaling_downScaling = (SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds)
-> (SetLoadBasedAutoScaling
    -> Maybe AutoScalingThresholds -> SetLoadBasedAutoScaling)
-> Lens
     SetLoadBasedAutoScaling
     SetLoadBasedAutoScaling
     (Maybe AutoScalingThresholds)
     (Maybe AutoScalingThresholds)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetLoadBasedAutoScaling' {Maybe AutoScalingThresholds
downScaling :: Maybe AutoScalingThresholds
$sel:downScaling:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds
downScaling} -> Maybe AutoScalingThresholds
downScaling) (\s :: SetLoadBasedAutoScaling
s@SetLoadBasedAutoScaling' {} Maybe AutoScalingThresholds
a -> SetLoadBasedAutoScaling
s {$sel:downScaling:SetLoadBasedAutoScaling' :: Maybe AutoScalingThresholds
downScaling = Maybe AutoScalingThresholds
a} :: SetLoadBasedAutoScaling)

-- | The layer ID.
setLoadBasedAutoScaling_layerId :: Lens.Lens' SetLoadBasedAutoScaling Prelude.Text
setLoadBasedAutoScaling_layerId :: (Text -> f Text)
-> SetLoadBasedAutoScaling -> f SetLoadBasedAutoScaling
setLoadBasedAutoScaling_layerId = (SetLoadBasedAutoScaling -> Text)
-> (SetLoadBasedAutoScaling -> Text -> SetLoadBasedAutoScaling)
-> Lens SetLoadBasedAutoScaling SetLoadBasedAutoScaling Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetLoadBasedAutoScaling' {Text
layerId :: Text
$sel:layerId:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Text
layerId} -> Text
layerId) (\s :: SetLoadBasedAutoScaling
s@SetLoadBasedAutoScaling' {} Text
a -> SetLoadBasedAutoScaling
s {$sel:layerId:SetLoadBasedAutoScaling' :: Text
layerId = Text
a} :: SetLoadBasedAutoScaling)

instance Core.AWSRequest SetLoadBasedAutoScaling where
  type
    AWSResponse SetLoadBasedAutoScaling =
      SetLoadBasedAutoScalingResponse
  request :: SetLoadBasedAutoScaling -> Request SetLoadBasedAutoScaling
request = Service
-> SetLoadBasedAutoScaling -> Request SetLoadBasedAutoScaling
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy SetLoadBasedAutoScaling
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse SetLoadBasedAutoScaling)))
response =
    AWSResponse SetLoadBasedAutoScaling
-> Logger
-> Service
-> Proxy SetLoadBasedAutoScaling
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse SetLoadBasedAutoScaling)))
forall (m :: * -> *) a.
MonadResource m =>
AWSResponse a
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveNull
      AWSResponse SetLoadBasedAutoScaling
SetLoadBasedAutoScalingResponse
SetLoadBasedAutoScalingResponse'

instance Prelude.Hashable SetLoadBasedAutoScaling

instance Prelude.NFData SetLoadBasedAutoScaling

instance Core.ToHeaders SetLoadBasedAutoScaling where
  toHeaders :: SetLoadBasedAutoScaling -> [Header]
toHeaders =
    [Header] -> SetLoadBasedAutoScaling -> [Header]
forall a b. a -> b -> a
Prelude.const
      ( [[Header]] -> [Header]
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> [Header]
forall a. ToHeader a => HeaderName -> a -> [Header]
Core.=# ( ByteString
"OpsWorks_20130218.SetLoadBasedAutoScaling" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> [Header]
forall a. ToHeader a => HeaderName -> a -> [Header]
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON SetLoadBasedAutoScaling where
  toJSON :: SetLoadBasedAutoScaling -> Value
toJSON SetLoadBasedAutoScaling' {Maybe Bool
Maybe AutoScalingThresholds
Text
layerId :: Text
downScaling :: Maybe AutoScalingThresholds
enable :: Maybe Bool
upScaling :: Maybe AutoScalingThresholds
$sel:layerId:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Text
$sel:downScaling:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds
$sel:enable:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Maybe Bool
$sel:upScaling:SetLoadBasedAutoScaling' :: SetLoadBasedAutoScaling -> Maybe AutoScalingThresholds
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"UpScaling" Text -> AutoScalingThresholds -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (AutoScalingThresholds -> Pair)
-> Maybe AutoScalingThresholds -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AutoScalingThresholds
upScaling,
            (Text
"Enable" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
enable,
            (Text
"DownScaling" Text -> AutoScalingThresholds -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (AutoScalingThresholds -> Pair)
-> Maybe AutoScalingThresholds -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AutoScalingThresholds
downScaling,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"LayerId" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
layerId)
          ]
      )

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

instance Core.ToQuery SetLoadBasedAutoScaling where
  toQuery :: SetLoadBasedAutoScaling -> QueryString
toQuery = QueryString -> SetLoadBasedAutoScaling -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newSetLoadBasedAutoScalingResponse' smart constructor.
data SetLoadBasedAutoScalingResponse = SetLoadBasedAutoScalingResponse'
  {
  }
  deriving (SetLoadBasedAutoScalingResponse
-> SetLoadBasedAutoScalingResponse -> Bool
(SetLoadBasedAutoScalingResponse
 -> SetLoadBasedAutoScalingResponse -> Bool)
-> (SetLoadBasedAutoScalingResponse
    -> SetLoadBasedAutoScalingResponse -> Bool)
-> Eq SetLoadBasedAutoScalingResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetLoadBasedAutoScalingResponse
-> SetLoadBasedAutoScalingResponse -> Bool
$c/= :: SetLoadBasedAutoScalingResponse
-> SetLoadBasedAutoScalingResponse -> Bool
== :: SetLoadBasedAutoScalingResponse
-> SetLoadBasedAutoScalingResponse -> Bool
$c== :: SetLoadBasedAutoScalingResponse
-> SetLoadBasedAutoScalingResponse -> Bool
Prelude.Eq, ReadPrec [SetLoadBasedAutoScalingResponse]
ReadPrec SetLoadBasedAutoScalingResponse
Int -> ReadS SetLoadBasedAutoScalingResponse
ReadS [SetLoadBasedAutoScalingResponse]
(Int -> ReadS SetLoadBasedAutoScalingResponse)
-> ReadS [SetLoadBasedAutoScalingResponse]
-> ReadPrec SetLoadBasedAutoScalingResponse
-> ReadPrec [SetLoadBasedAutoScalingResponse]
-> Read SetLoadBasedAutoScalingResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SetLoadBasedAutoScalingResponse]
$creadListPrec :: ReadPrec [SetLoadBasedAutoScalingResponse]
readPrec :: ReadPrec SetLoadBasedAutoScalingResponse
$creadPrec :: ReadPrec SetLoadBasedAutoScalingResponse
readList :: ReadS [SetLoadBasedAutoScalingResponse]
$creadList :: ReadS [SetLoadBasedAutoScalingResponse]
readsPrec :: Int -> ReadS SetLoadBasedAutoScalingResponse
$creadsPrec :: Int -> ReadS SetLoadBasedAutoScalingResponse
Prelude.Read, Int -> SetLoadBasedAutoScalingResponse -> ShowS
[SetLoadBasedAutoScalingResponse] -> ShowS
SetLoadBasedAutoScalingResponse -> String
(Int -> SetLoadBasedAutoScalingResponse -> ShowS)
-> (SetLoadBasedAutoScalingResponse -> String)
-> ([SetLoadBasedAutoScalingResponse] -> ShowS)
-> Show SetLoadBasedAutoScalingResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetLoadBasedAutoScalingResponse] -> ShowS
$cshowList :: [SetLoadBasedAutoScalingResponse] -> ShowS
show :: SetLoadBasedAutoScalingResponse -> String
$cshow :: SetLoadBasedAutoScalingResponse -> String
showsPrec :: Int -> SetLoadBasedAutoScalingResponse -> ShowS
$cshowsPrec :: Int -> SetLoadBasedAutoScalingResponse -> ShowS
Prelude.Show, (forall x.
 SetLoadBasedAutoScalingResponse
 -> Rep SetLoadBasedAutoScalingResponse x)
-> (forall x.
    Rep SetLoadBasedAutoScalingResponse x
    -> SetLoadBasedAutoScalingResponse)
-> Generic SetLoadBasedAutoScalingResponse
forall x.
Rep SetLoadBasedAutoScalingResponse x
-> SetLoadBasedAutoScalingResponse
forall x.
SetLoadBasedAutoScalingResponse
-> Rep SetLoadBasedAutoScalingResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep SetLoadBasedAutoScalingResponse x
-> SetLoadBasedAutoScalingResponse
$cfrom :: forall x.
SetLoadBasedAutoScalingResponse
-> Rep SetLoadBasedAutoScalingResponse x
Prelude.Generic)

-- |
-- Create a value of 'SetLoadBasedAutoScalingResponse' 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.
newSetLoadBasedAutoScalingResponse ::
  SetLoadBasedAutoScalingResponse
newSetLoadBasedAutoScalingResponse :: SetLoadBasedAutoScalingResponse
newSetLoadBasedAutoScalingResponse =
  SetLoadBasedAutoScalingResponse
SetLoadBasedAutoScalingResponse'

instance
  Prelude.NFData
    SetLoadBasedAutoScalingResponse