{-# 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.EC2.CreateCapacityReservationFleet
-- 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 Capacity Reservation Fleet. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-cr-fleets.html#create-crfleet Create a Capacity Reservation Fleet>
-- in the Amazon EC2 User Guide.
module Amazonka.EC2.CreateCapacityReservationFleet
  ( -- * Creating a Request
    CreateCapacityReservationFleet (..),
    newCreateCapacityReservationFleet,

    -- * Request Lenses
    createCapacityReservationFleet_allocationStrategy,
    createCapacityReservationFleet_clientToken,
    createCapacityReservationFleet_dryRun,
    createCapacityReservationFleet_endDate,
    createCapacityReservationFleet_instanceMatchCriteria,
    createCapacityReservationFleet_tagSpecifications,
    createCapacityReservationFleet_tenancy,
    createCapacityReservationFleet_instanceTypeSpecifications,
    createCapacityReservationFleet_totalTargetCapacity,

    -- * Destructuring the Response
    CreateCapacityReservationFleetResponse (..),
    newCreateCapacityReservationFleetResponse,

    -- * Response Lenses
    createCapacityReservationFleetResponse_allocationStrategy,
    createCapacityReservationFleetResponse_capacityReservationFleetId,
    createCapacityReservationFleetResponse_createTime,
    createCapacityReservationFleetResponse_endDate,
    createCapacityReservationFleetResponse_fleetCapacityReservations,
    createCapacityReservationFleetResponse_instanceMatchCriteria,
    createCapacityReservationFleetResponse_state,
    createCapacityReservationFleetResponse_tags,
    createCapacityReservationFleetResponse_tenancy,
    createCapacityReservationFleetResponse_totalFulfilledCapacity,
    createCapacityReservationFleetResponse_totalTargetCapacity,
    createCapacityReservationFleetResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateCapacityReservationFleet' smart constructor.
data CreateCapacityReservationFleet = CreateCapacityReservationFleet'
  { -- | The strategy used by the Capacity Reservation Fleet to determine which
    -- of the specified instance types to use. Currently, only the
    -- @prioritized@ allocation strategy is supported. For more information,
    -- see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy Allocation strategy>
    -- in the Amazon EC2 User Guide.
    --
    -- Valid values: @prioritized@
    CreateCapacityReservationFleet -> Maybe Text
allocationStrategy :: Prelude.Maybe Prelude.Text,
    -- | Unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request. For more information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html Ensure Idempotency>.
    CreateCapacityReservationFleet -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    CreateCapacityReservationFleet -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The date and time at which the Capacity Reservation Fleet expires. When
    -- the Capacity Reservation Fleet expires, its state changes to @expired@
    -- and all of the Capacity Reservations in the Fleet expire.
    --
    -- The Capacity Reservation Fleet expires within an hour after the
    -- specified time. For example, if you specify @5\/31\/2019@, @13:30:55@,
    -- the Capacity Reservation Fleet is guaranteed to expire between
    -- @13:30:55@ and @14:30:55@ on @5\/31\/2019@.
    CreateCapacityReservationFleet -> Maybe ISO8601
endDate :: Prelude.Maybe Data.ISO8601,
    -- | Indicates the type of instance launches that the Capacity Reservation
    -- Fleet accepts. All Capacity Reservations in the Fleet inherit this
    -- instance matching criteria.
    --
    -- Currently, Capacity Reservation Fleets support @open@ instance matching
    -- criteria only. This means that instances that have matching attributes
    -- (instance type, platform, and Availability Zone) run in the Capacity
    -- Reservations automatically. Instances do not need to explicitly target a
    -- Capacity Reservation Fleet to use its reserved capacity.
    CreateCapacityReservationFleet -> Maybe FleetInstanceMatchCriteria
instanceMatchCriteria :: Prelude.Maybe FleetInstanceMatchCriteria,
    -- | The tags to assign to the Capacity Reservation Fleet. The tags are
    -- automatically assigned to the Capacity Reservations in the Fleet.
    CreateCapacityReservationFleet -> Maybe [TagSpecification]
tagSpecifications :: Prelude.Maybe [TagSpecification],
    -- | Indicates the tenancy of the Capacity Reservation Fleet. All Capacity
    -- Reservations in the Fleet inherit this tenancy. The Capacity Reservation
    -- Fleet can have one of the following tenancy settings:
    --
    -- -   @default@ - The Capacity Reservation Fleet is created on hardware
    --     that is shared with other Amazon Web Services accounts.
    --
    -- -   @dedicated@ - The Capacity Reservations are created on single-tenant
    --     hardware that is dedicated to a single Amazon Web Services account.
    CreateCapacityReservationFleet
-> Maybe FleetCapacityReservationTenancy
tenancy :: Prelude.Maybe FleetCapacityReservationTenancy,
    -- | Information about the instance types for which to reserve the capacity.
    CreateCapacityReservationFleet
-> [ReservationFleetInstanceSpecification]
instanceTypeSpecifications :: [ReservationFleetInstanceSpecification],
    -- | The total number of capacity units to be reserved by the Capacity
    -- Reservation Fleet. This value, together with the instance type weights
    -- that you assign to each instance type used by the Fleet determine the
    -- number of instances for which the Fleet reserves capacity. Both values
    -- are based on units that make sense for your workload. For more
    -- information, see
    -- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity Total target capacity>
    -- in the Amazon EC2 User Guide.
    CreateCapacityReservationFleet -> Int
totalTargetCapacity :: Prelude.Int
  }
  deriving (CreateCapacityReservationFleet
-> CreateCapacityReservationFleet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCapacityReservationFleet
-> CreateCapacityReservationFleet -> Bool
$c/= :: CreateCapacityReservationFleet
-> CreateCapacityReservationFleet -> Bool
== :: CreateCapacityReservationFleet
-> CreateCapacityReservationFleet -> Bool
$c== :: CreateCapacityReservationFleet
-> CreateCapacityReservationFleet -> Bool
Prelude.Eq, ReadPrec [CreateCapacityReservationFleet]
ReadPrec CreateCapacityReservationFleet
Int -> ReadS CreateCapacityReservationFleet
ReadS [CreateCapacityReservationFleet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCapacityReservationFleet]
$creadListPrec :: ReadPrec [CreateCapacityReservationFleet]
readPrec :: ReadPrec CreateCapacityReservationFleet
$creadPrec :: ReadPrec CreateCapacityReservationFleet
readList :: ReadS [CreateCapacityReservationFleet]
$creadList :: ReadS [CreateCapacityReservationFleet]
readsPrec :: Int -> ReadS CreateCapacityReservationFleet
$creadsPrec :: Int -> ReadS CreateCapacityReservationFleet
Prelude.Read, Int -> CreateCapacityReservationFleet -> ShowS
[CreateCapacityReservationFleet] -> ShowS
CreateCapacityReservationFleet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCapacityReservationFleet] -> ShowS
$cshowList :: [CreateCapacityReservationFleet] -> ShowS
show :: CreateCapacityReservationFleet -> String
$cshow :: CreateCapacityReservationFleet -> String
showsPrec :: Int -> CreateCapacityReservationFleet -> ShowS
$cshowsPrec :: Int -> CreateCapacityReservationFleet -> ShowS
Prelude.Show, forall x.
Rep CreateCapacityReservationFleet x
-> CreateCapacityReservationFleet
forall x.
CreateCapacityReservationFleet
-> Rep CreateCapacityReservationFleet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateCapacityReservationFleet x
-> CreateCapacityReservationFleet
$cfrom :: forall x.
CreateCapacityReservationFleet
-> Rep CreateCapacityReservationFleet x
Prelude.Generic)

-- |
-- Create a value of 'CreateCapacityReservationFleet' 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:
--
-- 'allocationStrategy', 'createCapacityReservationFleet_allocationStrategy' - The strategy used by the Capacity Reservation Fleet to determine which
-- of the specified instance types to use. Currently, only the
-- @prioritized@ allocation strategy is supported. For more information,
-- see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy Allocation strategy>
-- in the Amazon EC2 User Guide.
--
-- Valid values: @prioritized@
--
-- 'clientToken', 'createCapacityReservationFleet_clientToken' - Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html Ensure Idempotency>.
--
-- 'dryRun', 'createCapacityReservationFleet_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'endDate', 'createCapacityReservationFleet_endDate' - The date and time at which the Capacity Reservation Fleet expires. When
-- the Capacity Reservation Fleet expires, its state changes to @expired@
-- and all of the Capacity Reservations in the Fleet expire.
--
-- The Capacity Reservation Fleet expires within an hour after the
-- specified time. For example, if you specify @5\/31\/2019@, @13:30:55@,
-- the Capacity Reservation Fleet is guaranteed to expire between
-- @13:30:55@ and @14:30:55@ on @5\/31\/2019@.
--
-- 'instanceMatchCriteria', 'createCapacityReservationFleet_instanceMatchCriteria' - Indicates the type of instance launches that the Capacity Reservation
-- Fleet accepts. All Capacity Reservations in the Fleet inherit this
-- instance matching criteria.
--
-- Currently, Capacity Reservation Fleets support @open@ instance matching
-- criteria only. This means that instances that have matching attributes
-- (instance type, platform, and Availability Zone) run in the Capacity
-- Reservations automatically. Instances do not need to explicitly target a
-- Capacity Reservation Fleet to use its reserved capacity.
--
-- 'tagSpecifications', 'createCapacityReservationFleet_tagSpecifications' - The tags to assign to the Capacity Reservation Fleet. The tags are
-- automatically assigned to the Capacity Reservations in the Fleet.
--
-- 'tenancy', 'createCapacityReservationFleet_tenancy' - Indicates the tenancy of the Capacity Reservation Fleet. All Capacity
-- Reservations in the Fleet inherit this tenancy. The Capacity Reservation
-- Fleet can have one of the following tenancy settings:
--
-- -   @default@ - The Capacity Reservation Fleet is created on hardware
--     that is shared with other Amazon Web Services accounts.
--
-- -   @dedicated@ - The Capacity Reservations are created on single-tenant
--     hardware that is dedicated to a single Amazon Web Services account.
--
-- 'instanceTypeSpecifications', 'createCapacityReservationFleet_instanceTypeSpecifications' - Information about the instance types for which to reserve the capacity.
--
-- 'totalTargetCapacity', 'createCapacityReservationFleet_totalTargetCapacity' - The total number of capacity units to be reserved by the Capacity
-- Reservation Fleet. This value, together with the instance type weights
-- that you assign to each instance type used by the Fleet determine the
-- number of instances for which the Fleet reserves capacity. Both values
-- are based on units that make sense for your workload. For more
-- information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity Total target capacity>
-- in the Amazon EC2 User Guide.
newCreateCapacityReservationFleet ::
  -- | 'totalTargetCapacity'
  Prelude.Int ->
  CreateCapacityReservationFleet
newCreateCapacityReservationFleet :: Int -> CreateCapacityReservationFleet
newCreateCapacityReservationFleet
  Int
pTotalTargetCapacity_ =
    CreateCapacityReservationFleet'
      { $sel:allocationStrategy:CreateCapacityReservationFleet' :: Maybe Text
allocationStrategy =
          forall a. Maybe a
Prelude.Nothing,
        $sel:clientToken:CreateCapacityReservationFleet' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
        $sel:dryRun:CreateCapacityReservationFleet' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
        $sel:endDate:CreateCapacityReservationFleet' :: Maybe ISO8601
endDate = forall a. Maybe a
Prelude.Nothing,
        $sel:instanceMatchCriteria:CreateCapacityReservationFleet' :: Maybe FleetInstanceMatchCriteria
instanceMatchCriteria = forall a. Maybe a
Prelude.Nothing,
        $sel:tagSpecifications:CreateCapacityReservationFleet' :: Maybe [TagSpecification]
tagSpecifications = forall a. Maybe a
Prelude.Nothing,
        $sel:tenancy:CreateCapacityReservationFleet' :: Maybe FleetCapacityReservationTenancy
tenancy = forall a. Maybe a
Prelude.Nothing,
        $sel:instanceTypeSpecifications:CreateCapacityReservationFleet' :: [ReservationFleetInstanceSpecification]
instanceTypeSpecifications = forall a. Monoid a => a
Prelude.mempty,
        $sel:totalTargetCapacity:CreateCapacityReservationFleet' :: Int
totalTargetCapacity = Int
pTotalTargetCapacity_
      }

-- | The strategy used by the Capacity Reservation Fleet to determine which
-- of the specified instance types to use. Currently, only the
-- @prioritized@ allocation strategy is supported. For more information,
-- see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#allocation-strategy Allocation strategy>
-- in the Amazon EC2 User Guide.
--
-- Valid values: @prioritized@
createCapacityReservationFleet_allocationStrategy :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe Prelude.Text)
createCapacityReservationFleet_allocationStrategy :: Lens' CreateCapacityReservationFleet (Maybe Text)
createCapacityReservationFleet_allocationStrategy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe Text
allocationStrategy :: Maybe Text
$sel:allocationStrategy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
allocationStrategy} -> Maybe Text
allocationStrategy) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe Text
a -> CreateCapacityReservationFleet
s {$sel:allocationStrategy:CreateCapacityReservationFleet' :: Maybe Text
allocationStrategy = Maybe Text
a} :: CreateCapacityReservationFleet)

-- | Unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html Ensure Idempotency>.
createCapacityReservationFleet_clientToken :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe Prelude.Text)
createCapacityReservationFleet_clientToken :: Lens' CreateCapacityReservationFleet (Maybe Text)
createCapacityReservationFleet_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe Text
a -> CreateCapacityReservationFleet
s {$sel:clientToken:CreateCapacityReservationFleet' :: Maybe Text
clientToken = Maybe Text
a} :: CreateCapacityReservationFleet)

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
createCapacityReservationFleet_dryRun :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe Prelude.Bool)
createCapacityReservationFleet_dryRun :: Lens' CreateCapacityReservationFleet (Maybe Bool)
createCapacityReservationFleet_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe Bool
a -> CreateCapacityReservationFleet
s {$sel:dryRun:CreateCapacityReservationFleet' :: Maybe Bool
dryRun = Maybe Bool
a} :: CreateCapacityReservationFleet)

-- | The date and time at which the Capacity Reservation Fleet expires. When
-- the Capacity Reservation Fleet expires, its state changes to @expired@
-- and all of the Capacity Reservations in the Fleet expire.
--
-- The Capacity Reservation Fleet expires within an hour after the
-- specified time. For example, if you specify @5\/31\/2019@, @13:30:55@,
-- the Capacity Reservation Fleet is guaranteed to expire between
-- @13:30:55@ and @14:30:55@ on @5\/31\/2019@.
createCapacityReservationFleet_endDate :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe Prelude.UTCTime)
createCapacityReservationFleet_endDate :: Lens' CreateCapacityReservationFleet (Maybe UTCTime)
createCapacityReservationFleet_endDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe ISO8601
endDate :: Maybe ISO8601
$sel:endDate:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe ISO8601
endDate} -> Maybe ISO8601
endDate) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe ISO8601
a -> CreateCapacityReservationFleet
s {$sel:endDate:CreateCapacityReservationFleet' :: Maybe ISO8601
endDate = Maybe ISO8601
a} :: CreateCapacityReservationFleet) 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

-- | Indicates the type of instance launches that the Capacity Reservation
-- Fleet accepts. All Capacity Reservations in the Fleet inherit this
-- instance matching criteria.
--
-- Currently, Capacity Reservation Fleets support @open@ instance matching
-- criteria only. This means that instances that have matching attributes
-- (instance type, platform, and Availability Zone) run in the Capacity
-- Reservations automatically. Instances do not need to explicitly target a
-- Capacity Reservation Fleet to use its reserved capacity.
createCapacityReservationFleet_instanceMatchCriteria :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe FleetInstanceMatchCriteria)
createCapacityReservationFleet_instanceMatchCriteria :: Lens'
  CreateCapacityReservationFleet (Maybe FleetInstanceMatchCriteria)
createCapacityReservationFleet_instanceMatchCriteria = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe FleetInstanceMatchCriteria
instanceMatchCriteria :: Maybe FleetInstanceMatchCriteria
$sel:instanceMatchCriteria:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe FleetInstanceMatchCriteria
instanceMatchCriteria} -> Maybe FleetInstanceMatchCriteria
instanceMatchCriteria) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe FleetInstanceMatchCriteria
a -> CreateCapacityReservationFleet
s {$sel:instanceMatchCriteria:CreateCapacityReservationFleet' :: Maybe FleetInstanceMatchCriteria
instanceMatchCriteria = Maybe FleetInstanceMatchCriteria
a} :: CreateCapacityReservationFleet)

-- | The tags to assign to the Capacity Reservation Fleet. The tags are
-- automatically assigned to the Capacity Reservations in the Fleet.
createCapacityReservationFleet_tagSpecifications :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe [TagSpecification])
createCapacityReservationFleet_tagSpecifications :: Lens' CreateCapacityReservationFleet (Maybe [TagSpecification])
createCapacityReservationFleet_tagSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe [TagSpecification]
tagSpecifications :: Maybe [TagSpecification]
$sel:tagSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe [TagSpecification]
tagSpecifications} -> Maybe [TagSpecification]
tagSpecifications) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe [TagSpecification]
a -> CreateCapacityReservationFleet
s {$sel:tagSpecifications:CreateCapacityReservationFleet' :: Maybe [TagSpecification]
tagSpecifications = Maybe [TagSpecification]
a} :: CreateCapacityReservationFleet) 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

-- | Indicates the tenancy of the Capacity Reservation Fleet. All Capacity
-- Reservations in the Fleet inherit this tenancy. The Capacity Reservation
-- Fleet can have one of the following tenancy settings:
--
-- -   @default@ - The Capacity Reservation Fleet is created on hardware
--     that is shared with other Amazon Web Services accounts.
--
-- -   @dedicated@ - The Capacity Reservations are created on single-tenant
--     hardware that is dedicated to a single Amazon Web Services account.
createCapacityReservationFleet_tenancy :: Lens.Lens' CreateCapacityReservationFleet (Prelude.Maybe FleetCapacityReservationTenancy)
createCapacityReservationFleet_tenancy :: Lens'
  CreateCapacityReservationFleet
  (Maybe FleetCapacityReservationTenancy)
createCapacityReservationFleet_tenancy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Maybe FleetCapacityReservationTenancy
tenancy :: Maybe FleetCapacityReservationTenancy
$sel:tenancy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> Maybe FleetCapacityReservationTenancy
tenancy} -> Maybe FleetCapacityReservationTenancy
tenancy) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Maybe FleetCapacityReservationTenancy
a -> CreateCapacityReservationFleet
s {$sel:tenancy:CreateCapacityReservationFleet' :: Maybe FleetCapacityReservationTenancy
tenancy = Maybe FleetCapacityReservationTenancy
a} :: CreateCapacityReservationFleet)

-- | Information about the instance types for which to reserve the capacity.
createCapacityReservationFleet_instanceTypeSpecifications :: Lens.Lens' CreateCapacityReservationFleet [ReservationFleetInstanceSpecification]
createCapacityReservationFleet_instanceTypeSpecifications :: Lens'
  CreateCapacityReservationFleet
  [ReservationFleetInstanceSpecification]
createCapacityReservationFleet_instanceTypeSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {[ReservationFleetInstanceSpecification]
instanceTypeSpecifications :: [ReservationFleetInstanceSpecification]
$sel:instanceTypeSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> [ReservationFleetInstanceSpecification]
instanceTypeSpecifications} -> [ReservationFleetInstanceSpecification]
instanceTypeSpecifications) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} [ReservationFleetInstanceSpecification]
a -> CreateCapacityReservationFleet
s {$sel:instanceTypeSpecifications:CreateCapacityReservationFleet' :: [ReservationFleetInstanceSpecification]
instanceTypeSpecifications = [ReservationFleetInstanceSpecification]
a} :: CreateCapacityReservationFleet) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The total number of capacity units to be reserved by the Capacity
-- Reservation Fleet. This value, together with the instance type weights
-- that you assign to each instance type used by the Fleet determine the
-- number of instances for which the Fleet reserves capacity. Both values
-- are based on units that make sense for your workload. For more
-- information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/crfleet-concepts.html#target-capacity Total target capacity>
-- in the Amazon EC2 User Guide.
createCapacityReservationFleet_totalTargetCapacity :: Lens.Lens' CreateCapacityReservationFleet Prelude.Int
createCapacityReservationFleet_totalTargetCapacity :: Lens' CreateCapacityReservationFleet Int
createCapacityReservationFleet_totalTargetCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleet' {Int
totalTargetCapacity :: Int
$sel:totalTargetCapacity:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Int
totalTargetCapacity} -> Int
totalTargetCapacity) (\s :: CreateCapacityReservationFleet
s@CreateCapacityReservationFleet' {} Int
a -> CreateCapacityReservationFleet
s {$sel:totalTargetCapacity:CreateCapacityReservationFleet' :: Int
totalTargetCapacity = Int
a} :: CreateCapacityReservationFleet)

instance
  Core.AWSRequest
    CreateCapacityReservationFleet
  where
  type
    AWSResponse CreateCapacityReservationFleet =
      CreateCapacityReservationFleetResponse
  request :: (Service -> Service)
-> CreateCapacityReservationFleet
-> Request CreateCapacityReservationFleet
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 CreateCapacityReservationFleet
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse CreateCapacityReservationFleet)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe Text
-> Maybe Text
-> Maybe ISO8601
-> Maybe ISO8601
-> Maybe [FleetCapacityReservation]
-> Maybe FleetInstanceMatchCriteria
-> Maybe CapacityReservationFleetState
-> Maybe [Tag]
-> Maybe FleetCapacityReservationTenancy
-> Maybe Double
-> Maybe Int
-> Int
-> CreateCapacityReservationFleetResponse
CreateCapacityReservationFleetResponse'
            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
"allocationStrategy")
            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
"capacityReservationFleetId")
            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
"createTime")
            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
"endDate")
            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
"fleetCapacityReservationSet"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                        )
            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
"instanceMatchCriteria")
            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
"state")
            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
"tagSet"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                        )
            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
"tenancy")
            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
"totalFulfilledCapacity")
            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
"totalTargetCapacity")
            forall (f :: * -> *) a b. Applicative f => 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
    CreateCapacityReservationFleet
  where
  hashWithSalt :: Int -> CreateCapacityReservationFleet -> Int
hashWithSalt
    Int
_salt
    CreateCapacityReservationFleet' {Int
[ReservationFleetInstanceSpecification]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe ISO8601
Maybe FleetCapacityReservationTenancy
Maybe FleetInstanceMatchCriteria
totalTargetCapacity :: Int
instanceTypeSpecifications :: [ReservationFleetInstanceSpecification]
tenancy :: Maybe FleetCapacityReservationTenancy
tagSpecifications :: Maybe [TagSpecification]
instanceMatchCriteria :: Maybe FleetInstanceMatchCriteria
endDate :: Maybe ISO8601
dryRun :: Maybe Bool
clientToken :: Maybe Text
allocationStrategy :: Maybe Text
$sel:totalTargetCapacity:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Int
$sel:instanceTypeSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> [ReservationFleetInstanceSpecification]
$sel:tenancy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> Maybe FleetCapacityReservationTenancy
$sel:tagSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe [TagSpecification]
$sel:instanceMatchCriteria:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe FleetInstanceMatchCriteria
$sel:endDate:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe ISO8601
$sel:dryRun:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Bool
$sel:clientToken:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
$sel:allocationStrategy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
allocationStrategy
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
endDate
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FleetInstanceMatchCriteria
instanceMatchCriteria
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TagSpecification]
tagSpecifications
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FleetCapacityReservationTenancy
tenancy
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [ReservationFleetInstanceSpecification]
instanceTypeSpecifications
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Int
totalTargetCapacity

instance
  Prelude.NFData
    CreateCapacityReservationFleet
  where
  rnf :: CreateCapacityReservationFleet -> ()
rnf CreateCapacityReservationFleet' {Int
[ReservationFleetInstanceSpecification]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe ISO8601
Maybe FleetCapacityReservationTenancy
Maybe FleetInstanceMatchCriteria
totalTargetCapacity :: Int
instanceTypeSpecifications :: [ReservationFleetInstanceSpecification]
tenancy :: Maybe FleetCapacityReservationTenancy
tagSpecifications :: Maybe [TagSpecification]
instanceMatchCriteria :: Maybe FleetInstanceMatchCriteria
endDate :: Maybe ISO8601
dryRun :: Maybe Bool
clientToken :: Maybe Text
allocationStrategy :: Maybe Text
$sel:totalTargetCapacity:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Int
$sel:instanceTypeSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> [ReservationFleetInstanceSpecification]
$sel:tenancy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> Maybe FleetCapacityReservationTenancy
$sel:tagSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe [TagSpecification]
$sel:instanceMatchCriteria:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe FleetInstanceMatchCriteria
$sel:endDate:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe ISO8601
$sel:dryRun:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Bool
$sel:clientToken:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
$sel:allocationStrategy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
allocationStrategy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
endDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FleetInstanceMatchCriteria
instanceMatchCriteria
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TagSpecification]
tagSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FleetCapacityReservationTenancy
tenancy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [ReservationFleetInstanceSpecification]
instanceTypeSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
totalTargetCapacity

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

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

instance Data.ToQuery CreateCapacityReservationFleet where
  toQuery :: CreateCapacityReservationFleet -> QueryString
toQuery CreateCapacityReservationFleet' {Int
[ReservationFleetInstanceSpecification]
Maybe Bool
Maybe [TagSpecification]
Maybe Text
Maybe ISO8601
Maybe FleetCapacityReservationTenancy
Maybe FleetInstanceMatchCriteria
totalTargetCapacity :: Int
instanceTypeSpecifications :: [ReservationFleetInstanceSpecification]
tenancy :: Maybe FleetCapacityReservationTenancy
tagSpecifications :: Maybe [TagSpecification]
instanceMatchCriteria :: Maybe FleetInstanceMatchCriteria
endDate :: Maybe ISO8601
dryRun :: Maybe Bool
clientToken :: Maybe Text
allocationStrategy :: Maybe Text
$sel:totalTargetCapacity:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Int
$sel:instanceTypeSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> [ReservationFleetInstanceSpecification]
$sel:tenancy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet
-> Maybe FleetCapacityReservationTenancy
$sel:tagSpecifications:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe [TagSpecification]
$sel:instanceMatchCriteria:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe FleetInstanceMatchCriteria
$sel:endDate:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe ISO8601
$sel:dryRun:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Bool
$sel:clientToken:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
$sel:allocationStrategy:CreateCapacityReservationFleet' :: CreateCapacityReservationFleet -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"CreateCapacityReservationFleet" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"AllocationStrategy" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
allocationStrategy,
        ByteString
"ClientToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
clientToken,
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"EndDate" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe ISO8601
endDate,
        ByteString
"InstanceMatchCriteria"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe FleetInstanceMatchCriteria
instanceMatchCriteria,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          ( forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"TagSpecification"
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [TagSpecification]
tagSpecifications
          ),
        ByteString
"Tenancy" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe FleetCapacityReservationTenancy
tenancy,
        forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList
          ByteString
"InstanceTypeSpecification"
          [ReservationFleetInstanceSpecification]
instanceTypeSpecifications,
        ByteString
"TotalTargetCapacity" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Int
totalTargetCapacity
      ]

-- | /See:/ 'newCreateCapacityReservationFleetResponse' smart constructor.
data CreateCapacityReservationFleetResponse = CreateCapacityReservationFleetResponse'
  { -- | The allocation strategy used by the Capacity Reservation Fleet.
    CreateCapacityReservationFleetResponse -> Maybe Text
allocationStrategy :: Prelude.Maybe Prelude.Text,
    -- | The ID of the Capacity Reservation Fleet.
    CreateCapacityReservationFleetResponse -> Maybe Text
capacityReservationFleetId :: Prelude.Maybe Prelude.Text,
    -- | The date and time at which the Capacity Reservation Fleet was created.
    CreateCapacityReservationFleetResponse -> Maybe ISO8601
createTime :: Prelude.Maybe Data.ISO8601,
    -- | The date and time at which the Capacity Reservation Fleet expires.
    CreateCapacityReservationFleetResponse -> Maybe ISO8601
endDate :: Prelude.Maybe Data.ISO8601,
    -- | Information about the individual Capacity Reservations in the Capacity
    -- Reservation Fleet.
    CreateCapacityReservationFleetResponse
-> Maybe [FleetCapacityReservation]
fleetCapacityReservations :: Prelude.Maybe [FleetCapacityReservation],
    -- | The instance matching criteria for the Capacity Reservation Fleet.
    CreateCapacityReservationFleetResponse
-> Maybe FleetInstanceMatchCriteria
instanceMatchCriteria :: Prelude.Maybe FleetInstanceMatchCriteria,
    -- | The status of the Capacity Reservation Fleet.
    CreateCapacityReservationFleetResponse
-> Maybe CapacityReservationFleetState
state :: Prelude.Maybe CapacityReservationFleetState,
    -- | The tags assigned to the Capacity Reservation Fleet.
    CreateCapacityReservationFleetResponse -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | Indicates the tenancy of Capacity Reservation Fleet.
    CreateCapacityReservationFleetResponse
-> Maybe FleetCapacityReservationTenancy
tenancy :: Prelude.Maybe FleetCapacityReservationTenancy,
    -- | The requested capacity units that have been successfully reserved.
    CreateCapacityReservationFleetResponse -> Maybe Double
totalFulfilledCapacity :: Prelude.Maybe Prelude.Double,
    -- | The total number of capacity units for which the Capacity Reservation
    -- Fleet reserves capacity.
    CreateCapacityReservationFleetResponse -> Maybe Int
totalTargetCapacity :: Prelude.Maybe Prelude.Int,
    -- | The response's http status code.
    CreateCapacityReservationFleetResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateCapacityReservationFleetResponse
-> CreateCapacityReservationFleetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCapacityReservationFleetResponse
-> CreateCapacityReservationFleetResponse -> Bool
$c/= :: CreateCapacityReservationFleetResponse
-> CreateCapacityReservationFleetResponse -> Bool
== :: CreateCapacityReservationFleetResponse
-> CreateCapacityReservationFleetResponse -> Bool
$c== :: CreateCapacityReservationFleetResponse
-> CreateCapacityReservationFleetResponse -> Bool
Prelude.Eq, ReadPrec [CreateCapacityReservationFleetResponse]
ReadPrec CreateCapacityReservationFleetResponse
Int -> ReadS CreateCapacityReservationFleetResponse
ReadS [CreateCapacityReservationFleetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCapacityReservationFleetResponse]
$creadListPrec :: ReadPrec [CreateCapacityReservationFleetResponse]
readPrec :: ReadPrec CreateCapacityReservationFleetResponse
$creadPrec :: ReadPrec CreateCapacityReservationFleetResponse
readList :: ReadS [CreateCapacityReservationFleetResponse]
$creadList :: ReadS [CreateCapacityReservationFleetResponse]
readsPrec :: Int -> ReadS CreateCapacityReservationFleetResponse
$creadsPrec :: Int -> ReadS CreateCapacityReservationFleetResponse
Prelude.Read, Int -> CreateCapacityReservationFleetResponse -> ShowS
[CreateCapacityReservationFleetResponse] -> ShowS
CreateCapacityReservationFleetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCapacityReservationFleetResponse] -> ShowS
$cshowList :: [CreateCapacityReservationFleetResponse] -> ShowS
show :: CreateCapacityReservationFleetResponse -> String
$cshow :: CreateCapacityReservationFleetResponse -> String
showsPrec :: Int -> CreateCapacityReservationFleetResponse -> ShowS
$cshowsPrec :: Int -> CreateCapacityReservationFleetResponse -> ShowS
Prelude.Show, forall x.
Rep CreateCapacityReservationFleetResponse x
-> CreateCapacityReservationFleetResponse
forall x.
CreateCapacityReservationFleetResponse
-> Rep CreateCapacityReservationFleetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateCapacityReservationFleetResponse x
-> CreateCapacityReservationFleetResponse
$cfrom :: forall x.
CreateCapacityReservationFleetResponse
-> Rep CreateCapacityReservationFleetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateCapacityReservationFleetResponse' 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:
--
-- 'allocationStrategy', 'createCapacityReservationFleetResponse_allocationStrategy' - The allocation strategy used by the Capacity Reservation Fleet.
--
-- 'capacityReservationFleetId', 'createCapacityReservationFleetResponse_capacityReservationFleetId' - The ID of the Capacity Reservation Fleet.
--
-- 'createTime', 'createCapacityReservationFleetResponse_createTime' - The date and time at which the Capacity Reservation Fleet was created.
--
-- 'endDate', 'createCapacityReservationFleetResponse_endDate' - The date and time at which the Capacity Reservation Fleet expires.
--
-- 'fleetCapacityReservations', 'createCapacityReservationFleetResponse_fleetCapacityReservations' - Information about the individual Capacity Reservations in the Capacity
-- Reservation Fleet.
--
-- 'instanceMatchCriteria', 'createCapacityReservationFleetResponse_instanceMatchCriteria' - The instance matching criteria for the Capacity Reservation Fleet.
--
-- 'state', 'createCapacityReservationFleetResponse_state' - The status of the Capacity Reservation Fleet.
--
-- 'tags', 'createCapacityReservationFleetResponse_tags' - The tags assigned to the Capacity Reservation Fleet.
--
-- 'tenancy', 'createCapacityReservationFleetResponse_tenancy' - Indicates the tenancy of Capacity Reservation Fleet.
--
-- 'totalFulfilledCapacity', 'createCapacityReservationFleetResponse_totalFulfilledCapacity' - The requested capacity units that have been successfully reserved.
--
-- 'totalTargetCapacity', 'createCapacityReservationFleetResponse_totalTargetCapacity' - The total number of capacity units for which the Capacity Reservation
-- Fleet reserves capacity.
--
-- 'httpStatus', 'createCapacityReservationFleetResponse_httpStatus' - The response's http status code.
newCreateCapacityReservationFleetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateCapacityReservationFleetResponse
newCreateCapacityReservationFleetResponse :: Int -> CreateCapacityReservationFleetResponse
newCreateCapacityReservationFleetResponse
  Int
pHttpStatus_ =
    CreateCapacityReservationFleetResponse'
      { $sel:allocationStrategy:CreateCapacityReservationFleetResponse' :: Maybe Text
allocationStrategy =
          forall a. Maybe a
Prelude.Nothing,
        $sel:capacityReservationFleetId:CreateCapacityReservationFleetResponse' :: Maybe Text
capacityReservationFleetId =
          forall a. Maybe a
Prelude.Nothing,
        $sel:createTime:CreateCapacityReservationFleetResponse' :: Maybe ISO8601
createTime = forall a. Maybe a
Prelude.Nothing,
        $sel:endDate:CreateCapacityReservationFleetResponse' :: Maybe ISO8601
endDate = forall a. Maybe a
Prelude.Nothing,
        $sel:fleetCapacityReservations:CreateCapacityReservationFleetResponse' :: Maybe [FleetCapacityReservation]
fleetCapacityReservations =
          forall a. Maybe a
Prelude.Nothing,
        $sel:instanceMatchCriteria:CreateCapacityReservationFleetResponse' :: Maybe FleetInstanceMatchCriteria
instanceMatchCriteria =
          forall a. Maybe a
Prelude.Nothing,
        $sel:state:CreateCapacityReservationFleetResponse' :: Maybe CapacityReservationFleetState
state = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateCapacityReservationFleetResponse' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:tenancy:CreateCapacityReservationFleetResponse' :: Maybe FleetCapacityReservationTenancy
tenancy = forall a. Maybe a
Prelude.Nothing,
        $sel:totalFulfilledCapacity:CreateCapacityReservationFleetResponse' :: Maybe Double
totalFulfilledCapacity =
          forall a. Maybe a
Prelude.Nothing,
        $sel:totalTargetCapacity:CreateCapacityReservationFleetResponse' :: Maybe Int
totalTargetCapacity =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:CreateCapacityReservationFleetResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | The allocation strategy used by the Capacity Reservation Fleet.
createCapacityReservationFleetResponse_allocationStrategy :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe Prelude.Text)
createCapacityReservationFleetResponse_allocationStrategy :: Lens' CreateCapacityReservationFleetResponse (Maybe Text)
createCapacityReservationFleetResponse_allocationStrategy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe Text
allocationStrategy :: Maybe Text
$sel:allocationStrategy:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Text
allocationStrategy} -> Maybe Text
allocationStrategy) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe Text
a -> CreateCapacityReservationFleetResponse
s {$sel:allocationStrategy:CreateCapacityReservationFleetResponse' :: Maybe Text
allocationStrategy = Maybe Text
a} :: CreateCapacityReservationFleetResponse)

-- | The ID of the Capacity Reservation Fleet.
createCapacityReservationFleetResponse_capacityReservationFleetId :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe Prelude.Text)
createCapacityReservationFleetResponse_capacityReservationFleetId :: Lens' CreateCapacityReservationFleetResponse (Maybe Text)
createCapacityReservationFleetResponse_capacityReservationFleetId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe Text
capacityReservationFleetId :: Maybe Text
$sel:capacityReservationFleetId:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Text
capacityReservationFleetId} -> Maybe Text
capacityReservationFleetId) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe Text
a -> CreateCapacityReservationFleetResponse
s {$sel:capacityReservationFleetId:CreateCapacityReservationFleetResponse' :: Maybe Text
capacityReservationFleetId = Maybe Text
a} :: CreateCapacityReservationFleetResponse)

-- | The date and time at which the Capacity Reservation Fleet was created.
createCapacityReservationFleetResponse_createTime :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe Prelude.UTCTime)
createCapacityReservationFleetResponse_createTime :: Lens' CreateCapacityReservationFleetResponse (Maybe UTCTime)
createCapacityReservationFleetResponse_createTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe ISO8601
createTime :: Maybe ISO8601
$sel:createTime:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe ISO8601
createTime} -> Maybe ISO8601
createTime) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe ISO8601
a -> CreateCapacityReservationFleetResponse
s {$sel:createTime:CreateCapacityReservationFleetResponse' :: Maybe ISO8601
createTime = Maybe ISO8601
a} :: CreateCapacityReservationFleetResponse) 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 date and time at which the Capacity Reservation Fleet expires.
createCapacityReservationFleetResponse_endDate :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe Prelude.UTCTime)
createCapacityReservationFleetResponse_endDate :: Lens' CreateCapacityReservationFleetResponse (Maybe UTCTime)
createCapacityReservationFleetResponse_endDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe ISO8601
endDate :: Maybe ISO8601
$sel:endDate:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe ISO8601
endDate} -> Maybe ISO8601
endDate) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe ISO8601
a -> CreateCapacityReservationFleetResponse
s {$sel:endDate:CreateCapacityReservationFleetResponse' :: Maybe ISO8601
endDate = Maybe ISO8601
a} :: CreateCapacityReservationFleetResponse) 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

-- | Information about the individual Capacity Reservations in the Capacity
-- Reservation Fleet.
createCapacityReservationFleetResponse_fleetCapacityReservations :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe [FleetCapacityReservation])
createCapacityReservationFleetResponse_fleetCapacityReservations :: Lens'
  CreateCapacityReservationFleetResponse
  (Maybe [FleetCapacityReservation])
createCapacityReservationFleetResponse_fleetCapacityReservations = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe [FleetCapacityReservation]
fleetCapacityReservations :: Maybe [FleetCapacityReservation]
$sel:fleetCapacityReservations:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe [FleetCapacityReservation]
fleetCapacityReservations} -> Maybe [FleetCapacityReservation]
fleetCapacityReservations) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe [FleetCapacityReservation]
a -> CreateCapacityReservationFleetResponse
s {$sel:fleetCapacityReservations:CreateCapacityReservationFleetResponse' :: Maybe [FleetCapacityReservation]
fleetCapacityReservations = Maybe [FleetCapacityReservation]
a} :: CreateCapacityReservationFleetResponse) 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 instance matching criteria for the Capacity Reservation Fleet.
createCapacityReservationFleetResponse_instanceMatchCriteria :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe FleetInstanceMatchCriteria)
createCapacityReservationFleetResponse_instanceMatchCriteria :: Lens'
  CreateCapacityReservationFleetResponse
  (Maybe FleetInstanceMatchCriteria)
createCapacityReservationFleetResponse_instanceMatchCriteria = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe FleetInstanceMatchCriteria
instanceMatchCriteria :: Maybe FleetInstanceMatchCriteria
$sel:instanceMatchCriteria:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe FleetInstanceMatchCriteria
instanceMatchCriteria} -> Maybe FleetInstanceMatchCriteria
instanceMatchCriteria) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe FleetInstanceMatchCriteria
a -> CreateCapacityReservationFleetResponse
s {$sel:instanceMatchCriteria:CreateCapacityReservationFleetResponse' :: Maybe FleetInstanceMatchCriteria
instanceMatchCriteria = Maybe FleetInstanceMatchCriteria
a} :: CreateCapacityReservationFleetResponse)

-- | The status of the Capacity Reservation Fleet.
createCapacityReservationFleetResponse_state :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe CapacityReservationFleetState)
createCapacityReservationFleetResponse_state :: Lens'
  CreateCapacityReservationFleetResponse
  (Maybe CapacityReservationFleetState)
createCapacityReservationFleetResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe CapacityReservationFleetState
state :: Maybe CapacityReservationFleetState
$sel:state:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe CapacityReservationFleetState
state} -> Maybe CapacityReservationFleetState
state) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe CapacityReservationFleetState
a -> CreateCapacityReservationFleetResponse
s {$sel:state:CreateCapacityReservationFleetResponse' :: Maybe CapacityReservationFleetState
state = Maybe CapacityReservationFleetState
a} :: CreateCapacityReservationFleetResponse)

-- | The tags assigned to the Capacity Reservation Fleet.
createCapacityReservationFleetResponse_tags :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe [Tag])
createCapacityReservationFleetResponse_tags :: Lens' CreateCapacityReservationFleetResponse (Maybe [Tag])
createCapacityReservationFleetResponse_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe [Tag]
a -> CreateCapacityReservationFleetResponse
s {$sel:tags:CreateCapacityReservationFleetResponse' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateCapacityReservationFleetResponse) 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

-- | Indicates the tenancy of Capacity Reservation Fleet.
createCapacityReservationFleetResponse_tenancy :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe FleetCapacityReservationTenancy)
createCapacityReservationFleetResponse_tenancy :: Lens'
  CreateCapacityReservationFleetResponse
  (Maybe FleetCapacityReservationTenancy)
createCapacityReservationFleetResponse_tenancy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe FleetCapacityReservationTenancy
tenancy :: Maybe FleetCapacityReservationTenancy
$sel:tenancy:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe FleetCapacityReservationTenancy
tenancy} -> Maybe FleetCapacityReservationTenancy
tenancy) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe FleetCapacityReservationTenancy
a -> CreateCapacityReservationFleetResponse
s {$sel:tenancy:CreateCapacityReservationFleetResponse' :: Maybe FleetCapacityReservationTenancy
tenancy = Maybe FleetCapacityReservationTenancy
a} :: CreateCapacityReservationFleetResponse)

-- | The requested capacity units that have been successfully reserved.
createCapacityReservationFleetResponse_totalFulfilledCapacity :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe Prelude.Double)
createCapacityReservationFleetResponse_totalFulfilledCapacity :: Lens' CreateCapacityReservationFleetResponse (Maybe Double)
createCapacityReservationFleetResponse_totalFulfilledCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe Double
totalFulfilledCapacity :: Maybe Double
$sel:totalFulfilledCapacity:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Double
totalFulfilledCapacity} -> Maybe Double
totalFulfilledCapacity) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe Double
a -> CreateCapacityReservationFleetResponse
s {$sel:totalFulfilledCapacity:CreateCapacityReservationFleetResponse' :: Maybe Double
totalFulfilledCapacity = Maybe Double
a} :: CreateCapacityReservationFleetResponse)

-- | The total number of capacity units for which the Capacity Reservation
-- Fleet reserves capacity.
createCapacityReservationFleetResponse_totalTargetCapacity :: Lens.Lens' CreateCapacityReservationFleetResponse (Prelude.Maybe Prelude.Int)
createCapacityReservationFleetResponse_totalTargetCapacity :: Lens' CreateCapacityReservationFleetResponse (Maybe Int)
createCapacityReservationFleetResponse_totalTargetCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCapacityReservationFleetResponse' {Maybe Int
totalTargetCapacity :: Maybe Int
$sel:totalTargetCapacity:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Int
totalTargetCapacity} -> Maybe Int
totalTargetCapacity) (\s :: CreateCapacityReservationFleetResponse
s@CreateCapacityReservationFleetResponse' {} Maybe Int
a -> CreateCapacityReservationFleetResponse
s {$sel:totalTargetCapacity:CreateCapacityReservationFleetResponse' :: Maybe Int
totalTargetCapacity = Maybe Int
a} :: CreateCapacityReservationFleetResponse)

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

instance
  Prelude.NFData
    CreateCapacityReservationFleetResponse
  where
  rnf :: CreateCapacityReservationFleetResponse -> ()
rnf CreateCapacityReservationFleetResponse' {Int
Maybe Double
Maybe Int
Maybe [FleetCapacityReservation]
Maybe [Tag]
Maybe Text
Maybe ISO8601
Maybe CapacityReservationFleetState
Maybe FleetCapacityReservationTenancy
Maybe FleetInstanceMatchCriteria
httpStatus :: Int
totalTargetCapacity :: Maybe Int
totalFulfilledCapacity :: Maybe Double
tenancy :: Maybe FleetCapacityReservationTenancy
tags :: Maybe [Tag]
state :: Maybe CapacityReservationFleetState
instanceMatchCriteria :: Maybe FleetInstanceMatchCriteria
fleetCapacityReservations :: Maybe [FleetCapacityReservation]
endDate :: Maybe ISO8601
createTime :: Maybe ISO8601
capacityReservationFleetId :: Maybe Text
allocationStrategy :: Maybe Text
$sel:httpStatus:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Int
$sel:totalTargetCapacity:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Int
$sel:totalFulfilledCapacity:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Double
$sel:tenancy:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe FleetCapacityReservationTenancy
$sel:tags:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe [Tag]
$sel:state:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe CapacityReservationFleetState
$sel:instanceMatchCriteria:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe FleetInstanceMatchCriteria
$sel:fleetCapacityReservations:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse
-> Maybe [FleetCapacityReservation]
$sel:endDate:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe ISO8601
$sel:createTime:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe ISO8601
$sel:capacityReservationFleetId:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Text
$sel:allocationStrategy:CreateCapacityReservationFleetResponse' :: CreateCapacityReservationFleetResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
allocationStrategy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
capacityReservationFleetId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
createTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
endDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [FleetCapacityReservation]
fleetCapacityReservations
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FleetInstanceMatchCriteria
instanceMatchCriteria
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CapacityReservationFleetState
state
      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 FleetCapacityReservationTenancy
tenancy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
totalFulfilledCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
totalTargetCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus