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

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

-- |
-- Module      : Amazonka.EC2.Types.LaunchTemplateOverrides
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.EC2.Types.LaunchTemplateOverrides where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.InstanceRequirements
import Amazonka.EC2.Types.InstanceType
import qualified Amazonka.Prelude as Prelude

-- | Describes overrides for a launch template.
--
-- /See:/ 'newLaunchTemplateOverrides' smart constructor.
data LaunchTemplateOverrides = LaunchTemplateOverrides'
  { -- | The Availability Zone in which to launch the instances.
    LaunchTemplateOverrides -> Maybe Text
availabilityZone :: Prelude.Maybe Prelude.Text,
    -- | The instance requirements. When you specify instance requirements,
    -- Amazon EC2 will identify instance types with the provided requirements,
    -- and then use your On-Demand and Spot allocation strategies to launch
    -- instances from these instance types, in the same way as when you specify
    -- a list of instance types.
    --
    -- If you specify @InstanceRequirements@, you can\'t specify
    -- @InstanceType@.
    LaunchTemplateOverrides -> Maybe InstanceRequirements
instanceRequirements :: Prelude.Maybe InstanceRequirements,
    -- | The instance type.
    LaunchTemplateOverrides -> Maybe InstanceType
instanceType :: Prelude.Maybe InstanceType,
    -- | The priority for the launch template override. The highest priority is
    -- launched first.
    --
    -- If @OnDemandAllocationStrategy@ is set to @prioritized@, Spot Fleet uses
    -- priority to determine which launch template override to use first in
    -- fulfilling On-Demand capacity.
    --
    -- If the Spot @AllocationStrategy@ is set to
    -- @capacityOptimizedPrioritized@, Spot Fleet uses priority on a
    -- best-effort basis to determine which launch template override to use in
    -- fulfilling Spot capacity, but optimizes for capacity first.
    --
    -- Valid values are whole numbers starting at @0@. The lower the number,
    -- the higher the priority. If no number is set, the launch template
    -- override has the lowest priority. You can set the same priority for
    -- different launch template overrides.
    LaunchTemplateOverrides -> Maybe Double
priority :: Prelude.Maybe Prelude.Double,
    -- | The maximum price per unit hour that you are willing to pay for a Spot
    -- Instance. We do not recommend using this parameter because it can lead
    -- to increased interruptions. If you do not specify this parameter, you
    -- will pay the current Spot price.
    --
    -- If you specify a maximum price, your instances will be interrupted more
    -- frequently than if you do not specify this parameter.
    LaunchTemplateOverrides -> Maybe Text
spotPrice :: Prelude.Maybe Prelude.Text,
    -- | The ID of the subnet in which to launch the instances.
    LaunchTemplateOverrides -> Maybe Text
subnetId :: Prelude.Maybe Prelude.Text,
    -- | The number of units provided by the specified instance type.
    LaunchTemplateOverrides -> Maybe Double
weightedCapacity :: Prelude.Maybe Prelude.Double
  }
  deriving (LaunchTemplateOverrides -> LaunchTemplateOverrides -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LaunchTemplateOverrides -> LaunchTemplateOverrides -> Bool
$c/= :: LaunchTemplateOverrides -> LaunchTemplateOverrides -> Bool
== :: LaunchTemplateOverrides -> LaunchTemplateOverrides -> Bool
$c== :: LaunchTemplateOverrides -> LaunchTemplateOverrides -> Bool
Prelude.Eq, ReadPrec [LaunchTemplateOverrides]
ReadPrec LaunchTemplateOverrides
Int -> ReadS LaunchTemplateOverrides
ReadS [LaunchTemplateOverrides]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LaunchTemplateOverrides]
$creadListPrec :: ReadPrec [LaunchTemplateOverrides]
readPrec :: ReadPrec LaunchTemplateOverrides
$creadPrec :: ReadPrec LaunchTemplateOverrides
readList :: ReadS [LaunchTemplateOverrides]
$creadList :: ReadS [LaunchTemplateOverrides]
readsPrec :: Int -> ReadS LaunchTemplateOverrides
$creadsPrec :: Int -> ReadS LaunchTemplateOverrides
Prelude.Read, Int -> LaunchTemplateOverrides -> ShowS
[LaunchTemplateOverrides] -> ShowS
LaunchTemplateOverrides -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LaunchTemplateOverrides] -> ShowS
$cshowList :: [LaunchTemplateOverrides] -> ShowS
show :: LaunchTemplateOverrides -> String
$cshow :: LaunchTemplateOverrides -> String
showsPrec :: Int -> LaunchTemplateOverrides -> ShowS
$cshowsPrec :: Int -> LaunchTemplateOverrides -> ShowS
Prelude.Show, forall x. Rep LaunchTemplateOverrides x -> LaunchTemplateOverrides
forall x. LaunchTemplateOverrides -> Rep LaunchTemplateOverrides x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LaunchTemplateOverrides x -> LaunchTemplateOverrides
$cfrom :: forall x. LaunchTemplateOverrides -> Rep LaunchTemplateOverrides x
Prelude.Generic)

-- |
-- Create a value of 'LaunchTemplateOverrides' 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:
--
-- 'availabilityZone', 'launchTemplateOverrides_availabilityZone' - The Availability Zone in which to launch the instances.
--
-- 'instanceRequirements', 'launchTemplateOverrides_instanceRequirements' - The instance requirements. When you specify instance requirements,
-- Amazon EC2 will identify instance types with the provided requirements,
-- and then use your On-Demand and Spot allocation strategies to launch
-- instances from these instance types, in the same way as when you specify
-- a list of instance types.
--
-- If you specify @InstanceRequirements@, you can\'t specify
-- @InstanceType@.
--
-- 'instanceType', 'launchTemplateOverrides_instanceType' - The instance type.
--
-- 'priority', 'launchTemplateOverrides_priority' - The priority for the launch template override. The highest priority is
-- launched first.
--
-- If @OnDemandAllocationStrategy@ is set to @prioritized@, Spot Fleet uses
-- priority to determine which launch template override to use first in
-- fulfilling On-Demand capacity.
--
-- If the Spot @AllocationStrategy@ is set to
-- @capacityOptimizedPrioritized@, Spot Fleet uses priority on a
-- best-effort basis to determine which launch template override to use in
-- fulfilling Spot capacity, but optimizes for capacity first.
--
-- Valid values are whole numbers starting at @0@. The lower the number,
-- the higher the priority. If no number is set, the launch template
-- override has the lowest priority. You can set the same priority for
-- different launch template overrides.
--
-- 'spotPrice', 'launchTemplateOverrides_spotPrice' - The maximum price per unit hour that you are willing to pay for a Spot
-- Instance. We do not recommend using this parameter because it can lead
-- to increased interruptions. If you do not specify this parameter, you
-- will pay the current Spot price.
--
-- If you specify a maximum price, your instances will be interrupted more
-- frequently than if you do not specify this parameter.
--
-- 'subnetId', 'launchTemplateOverrides_subnetId' - The ID of the subnet in which to launch the instances.
--
-- 'weightedCapacity', 'launchTemplateOverrides_weightedCapacity' - The number of units provided by the specified instance type.
newLaunchTemplateOverrides ::
  LaunchTemplateOverrides
newLaunchTemplateOverrides :: LaunchTemplateOverrides
newLaunchTemplateOverrides =
  LaunchTemplateOverrides'
    { $sel:availabilityZone:LaunchTemplateOverrides' :: Maybe Text
availabilityZone =
        forall a. Maybe a
Prelude.Nothing,
      $sel:instanceRequirements:LaunchTemplateOverrides' :: Maybe InstanceRequirements
instanceRequirements = forall a. Maybe a
Prelude.Nothing,
      $sel:instanceType:LaunchTemplateOverrides' :: Maybe InstanceType
instanceType = forall a. Maybe a
Prelude.Nothing,
      $sel:priority:LaunchTemplateOverrides' :: Maybe Double
priority = forall a. Maybe a
Prelude.Nothing,
      $sel:spotPrice:LaunchTemplateOverrides' :: Maybe Text
spotPrice = forall a. Maybe a
Prelude.Nothing,
      $sel:subnetId:LaunchTemplateOverrides' :: Maybe Text
subnetId = forall a. Maybe a
Prelude.Nothing,
      $sel:weightedCapacity:LaunchTemplateOverrides' :: Maybe Double
weightedCapacity = forall a. Maybe a
Prelude.Nothing
    }

-- | The Availability Zone in which to launch the instances.
launchTemplateOverrides_availabilityZone :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe Prelude.Text)
launchTemplateOverrides_availabilityZone :: Lens' LaunchTemplateOverrides (Maybe Text)
launchTemplateOverrides_availabilityZone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe Text
availabilityZone :: Maybe Text
$sel:availabilityZone:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
availabilityZone} -> Maybe Text
availabilityZone) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe Text
a -> LaunchTemplateOverrides
s {$sel:availabilityZone:LaunchTemplateOverrides' :: Maybe Text
availabilityZone = Maybe Text
a} :: LaunchTemplateOverrides)

-- | The instance requirements. When you specify instance requirements,
-- Amazon EC2 will identify instance types with the provided requirements,
-- and then use your On-Demand and Spot allocation strategies to launch
-- instances from these instance types, in the same way as when you specify
-- a list of instance types.
--
-- If you specify @InstanceRequirements@, you can\'t specify
-- @InstanceType@.
launchTemplateOverrides_instanceRequirements :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe InstanceRequirements)
launchTemplateOverrides_instanceRequirements :: Lens' LaunchTemplateOverrides (Maybe InstanceRequirements)
launchTemplateOverrides_instanceRequirements = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe InstanceRequirements
instanceRequirements :: Maybe InstanceRequirements
$sel:instanceRequirements:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceRequirements
instanceRequirements} -> Maybe InstanceRequirements
instanceRequirements) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe InstanceRequirements
a -> LaunchTemplateOverrides
s {$sel:instanceRequirements:LaunchTemplateOverrides' :: Maybe InstanceRequirements
instanceRequirements = Maybe InstanceRequirements
a} :: LaunchTemplateOverrides)

-- | The instance type.
launchTemplateOverrides_instanceType :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe InstanceType)
launchTemplateOverrides_instanceType :: Lens' LaunchTemplateOverrides (Maybe InstanceType)
launchTemplateOverrides_instanceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe InstanceType
instanceType :: Maybe InstanceType
$sel:instanceType:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceType
instanceType} -> Maybe InstanceType
instanceType) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe InstanceType
a -> LaunchTemplateOverrides
s {$sel:instanceType:LaunchTemplateOverrides' :: Maybe InstanceType
instanceType = Maybe InstanceType
a} :: LaunchTemplateOverrides)

-- | The priority for the launch template override. The highest priority is
-- launched first.
--
-- If @OnDemandAllocationStrategy@ is set to @prioritized@, Spot Fleet uses
-- priority to determine which launch template override to use first in
-- fulfilling On-Demand capacity.
--
-- If the Spot @AllocationStrategy@ is set to
-- @capacityOptimizedPrioritized@, Spot Fleet uses priority on a
-- best-effort basis to determine which launch template override to use in
-- fulfilling Spot capacity, but optimizes for capacity first.
--
-- Valid values are whole numbers starting at @0@. The lower the number,
-- the higher the priority. If no number is set, the launch template
-- override has the lowest priority. You can set the same priority for
-- different launch template overrides.
launchTemplateOverrides_priority :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe Prelude.Double)
launchTemplateOverrides_priority :: Lens' LaunchTemplateOverrides (Maybe Double)
launchTemplateOverrides_priority = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe Double
priority :: Maybe Double
$sel:priority:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
priority} -> Maybe Double
priority) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe Double
a -> LaunchTemplateOverrides
s {$sel:priority:LaunchTemplateOverrides' :: Maybe Double
priority = Maybe Double
a} :: LaunchTemplateOverrides)

-- | The maximum price per unit hour that you are willing to pay for a Spot
-- Instance. We do not recommend using this parameter because it can lead
-- to increased interruptions. If you do not specify this parameter, you
-- will pay the current Spot price.
--
-- If you specify a maximum price, your instances will be interrupted more
-- frequently than if you do not specify this parameter.
launchTemplateOverrides_spotPrice :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe Prelude.Text)
launchTemplateOverrides_spotPrice :: Lens' LaunchTemplateOverrides (Maybe Text)
launchTemplateOverrides_spotPrice = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe Text
spotPrice :: Maybe Text
$sel:spotPrice:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
spotPrice} -> Maybe Text
spotPrice) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe Text
a -> LaunchTemplateOverrides
s {$sel:spotPrice:LaunchTemplateOverrides' :: Maybe Text
spotPrice = Maybe Text
a} :: LaunchTemplateOverrides)

-- | The ID of the subnet in which to launch the instances.
launchTemplateOverrides_subnetId :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe Prelude.Text)
launchTemplateOverrides_subnetId :: Lens' LaunchTemplateOverrides (Maybe Text)
launchTemplateOverrides_subnetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe Text
subnetId :: Maybe Text
$sel:subnetId:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
subnetId} -> Maybe Text
subnetId) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe Text
a -> LaunchTemplateOverrides
s {$sel:subnetId:LaunchTemplateOverrides' :: Maybe Text
subnetId = Maybe Text
a} :: LaunchTemplateOverrides)

-- | The number of units provided by the specified instance type.
launchTemplateOverrides_weightedCapacity :: Lens.Lens' LaunchTemplateOverrides (Prelude.Maybe Prelude.Double)
launchTemplateOverrides_weightedCapacity :: Lens' LaunchTemplateOverrides (Maybe Double)
launchTemplateOverrides_weightedCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LaunchTemplateOverrides' {Maybe Double
weightedCapacity :: Maybe Double
$sel:weightedCapacity:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
weightedCapacity} -> Maybe Double
weightedCapacity) (\s :: LaunchTemplateOverrides
s@LaunchTemplateOverrides' {} Maybe Double
a -> LaunchTemplateOverrides
s {$sel:weightedCapacity:LaunchTemplateOverrides' :: Maybe Double
weightedCapacity = Maybe Double
a} :: LaunchTemplateOverrides)

instance Data.FromXML LaunchTemplateOverrides where
  parseXML :: [Node] -> Either String LaunchTemplateOverrides
parseXML [Node]
x =
    Maybe Text
-> Maybe InstanceRequirements
-> Maybe InstanceType
-> Maybe Double
-> Maybe Text
-> Maybe Text
-> Maybe Double
-> LaunchTemplateOverrides
LaunchTemplateOverrides'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"availabilityZone")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"instanceRequirements")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"instanceType")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"priority")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"spotPrice")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"subnetId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"weightedCapacity")

instance Prelude.Hashable LaunchTemplateOverrides where
  hashWithSalt :: Int -> LaunchTemplateOverrides -> Int
hashWithSalt Int
_salt LaunchTemplateOverrides' {Maybe Double
Maybe Text
Maybe InstanceType
Maybe InstanceRequirements
weightedCapacity :: Maybe Double
subnetId :: Maybe Text
spotPrice :: Maybe Text
priority :: Maybe Double
instanceType :: Maybe InstanceType
instanceRequirements :: Maybe InstanceRequirements
availabilityZone :: Maybe Text
$sel:weightedCapacity:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
$sel:subnetId:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
$sel:spotPrice:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
$sel:priority:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
$sel:instanceType:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceType
$sel:instanceRequirements:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceRequirements
$sel:availabilityZone:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
availabilityZone
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InstanceRequirements
instanceRequirements
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe InstanceType
instanceType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
priority
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
spotPrice
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
subnetId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
weightedCapacity

instance Prelude.NFData LaunchTemplateOverrides where
  rnf :: LaunchTemplateOverrides -> ()
rnf LaunchTemplateOverrides' {Maybe Double
Maybe Text
Maybe InstanceType
Maybe InstanceRequirements
weightedCapacity :: Maybe Double
subnetId :: Maybe Text
spotPrice :: Maybe Text
priority :: Maybe Double
instanceType :: Maybe InstanceType
instanceRequirements :: Maybe InstanceRequirements
availabilityZone :: Maybe Text
$sel:weightedCapacity:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
$sel:subnetId:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
$sel:spotPrice:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
$sel:priority:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
$sel:instanceType:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceType
$sel:instanceRequirements:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceRequirements
$sel:availabilityZone:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
availabilityZone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InstanceRequirements
instanceRequirements
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe InstanceType
instanceType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
priority
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
spotPrice
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
subnetId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
weightedCapacity

instance Data.ToQuery LaunchTemplateOverrides where
  toQuery :: LaunchTemplateOverrides -> QueryString
toQuery LaunchTemplateOverrides' {Maybe Double
Maybe Text
Maybe InstanceType
Maybe InstanceRequirements
weightedCapacity :: Maybe Double
subnetId :: Maybe Text
spotPrice :: Maybe Text
priority :: Maybe Double
instanceType :: Maybe InstanceType
instanceRequirements :: Maybe InstanceRequirements
availabilityZone :: Maybe Text
$sel:weightedCapacity:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
$sel:subnetId:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
$sel:spotPrice:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
$sel:priority:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Double
$sel:instanceType:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceType
$sel:instanceRequirements:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe InstanceRequirements
$sel:availabilityZone:LaunchTemplateOverrides' :: LaunchTemplateOverrides -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"AvailabilityZone" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
availabilityZone,
        ByteString
"InstanceRequirements" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe InstanceRequirements
instanceRequirements,
        ByteString
"InstanceType" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe InstanceType
instanceType,
        ByteString
"Priority" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Double
priority,
        ByteString
"SpotPrice" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
spotPrice,
        ByteString
"SubnetId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
subnetId,
        ByteString
"WeightedCapacity" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Double
weightedCapacity
      ]