{-# 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.GetCapacityReservationUsage
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets usage information about a Capacity Reservation. If the Capacity
-- Reservation is shared, it shows usage information for the Capacity
-- Reservation owner and each Amazon Web Services account that is currently
-- using the shared capacity. If the Capacity Reservation is not shared, it
-- shows only the Capacity Reservation owner\'s usage.
module Amazonka.EC2.GetCapacityReservationUsage
  ( -- * Creating a Request
    GetCapacityReservationUsage (..),
    newGetCapacityReservationUsage,

    -- * Request Lenses
    getCapacityReservationUsage_dryRun,
    getCapacityReservationUsage_maxResults,
    getCapacityReservationUsage_nextToken,
    getCapacityReservationUsage_capacityReservationId,

    -- * Destructuring the Response
    GetCapacityReservationUsageResponse (..),
    newGetCapacityReservationUsageResponse,

    -- * Response Lenses
    getCapacityReservationUsageResponse_availableInstanceCount,
    getCapacityReservationUsageResponse_capacityReservationId,
    getCapacityReservationUsageResponse_instanceType,
    getCapacityReservationUsageResponse_instanceUsages,
    getCapacityReservationUsageResponse_nextToken,
    getCapacityReservationUsageResponse_state,
    getCapacityReservationUsageResponse_totalInstanceCount,
    getCapacityReservationUsageResponse_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:/ 'newGetCapacityReservationUsage' smart constructor.
data GetCapacityReservationUsage = GetCapacityReservationUsage'
  { -- | 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@.
    GetCapacityReservationUsage -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The maximum number of results to return for the request in a single
    -- page. The remaining results can be seen by sending another request with
    -- the returned @nextToken@ value. This value can be between 5 and 500. If
    -- @maxResults@ is given a larger value than 500, you receive an error.
    --
    -- Valid range: Minimum value of 1. Maximum value of 1000.
    GetCapacityReservationUsage -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token to use to retrieve the next page of results.
    GetCapacityReservationUsage -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The ID of the Capacity Reservation.
    GetCapacityReservationUsage -> Text
capacityReservationId :: Prelude.Text
  }
  deriving (GetCapacityReservationUsage -> GetCapacityReservationUsage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetCapacityReservationUsage -> GetCapacityReservationUsage -> Bool
$c/= :: GetCapacityReservationUsage -> GetCapacityReservationUsage -> Bool
== :: GetCapacityReservationUsage -> GetCapacityReservationUsage -> Bool
$c== :: GetCapacityReservationUsage -> GetCapacityReservationUsage -> Bool
Prelude.Eq, ReadPrec [GetCapacityReservationUsage]
ReadPrec GetCapacityReservationUsage
Int -> ReadS GetCapacityReservationUsage
ReadS [GetCapacityReservationUsage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetCapacityReservationUsage]
$creadListPrec :: ReadPrec [GetCapacityReservationUsage]
readPrec :: ReadPrec GetCapacityReservationUsage
$creadPrec :: ReadPrec GetCapacityReservationUsage
readList :: ReadS [GetCapacityReservationUsage]
$creadList :: ReadS [GetCapacityReservationUsage]
readsPrec :: Int -> ReadS GetCapacityReservationUsage
$creadsPrec :: Int -> ReadS GetCapacityReservationUsage
Prelude.Read, Int -> GetCapacityReservationUsage -> ShowS
[GetCapacityReservationUsage] -> ShowS
GetCapacityReservationUsage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetCapacityReservationUsage] -> ShowS
$cshowList :: [GetCapacityReservationUsage] -> ShowS
show :: GetCapacityReservationUsage -> String
$cshow :: GetCapacityReservationUsage -> String
showsPrec :: Int -> GetCapacityReservationUsage -> ShowS
$cshowsPrec :: Int -> GetCapacityReservationUsage -> ShowS
Prelude.Show, forall x.
Rep GetCapacityReservationUsage x -> GetCapacityReservationUsage
forall x.
GetCapacityReservationUsage -> Rep GetCapacityReservationUsage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetCapacityReservationUsage x -> GetCapacityReservationUsage
$cfrom :: forall x.
GetCapacityReservationUsage -> Rep GetCapacityReservationUsage x
Prelude.Generic)

-- |
-- Create a value of 'GetCapacityReservationUsage' 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:
--
-- 'dryRun', 'getCapacityReservationUsage_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@.
--
-- 'maxResults', 'getCapacityReservationUsage_maxResults' - The maximum number of results to return for the request in a single
-- page. The remaining results can be seen by sending another request with
-- the returned @nextToken@ value. This value can be between 5 and 500. If
-- @maxResults@ is given a larger value than 500, you receive an error.
--
-- Valid range: Minimum value of 1. Maximum value of 1000.
--
-- 'nextToken', 'getCapacityReservationUsage_nextToken' - The token to use to retrieve the next page of results.
--
-- 'capacityReservationId', 'getCapacityReservationUsage_capacityReservationId' - The ID of the Capacity Reservation.
newGetCapacityReservationUsage ::
  -- | 'capacityReservationId'
  Prelude.Text ->
  GetCapacityReservationUsage
newGetCapacityReservationUsage :: Text -> GetCapacityReservationUsage
newGetCapacityReservationUsage
  Text
pCapacityReservationId_ =
    GetCapacityReservationUsage'
      { $sel:dryRun:GetCapacityReservationUsage' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:maxResults:GetCapacityReservationUsage' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:GetCapacityReservationUsage' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:capacityReservationId:GetCapacityReservationUsage' :: Text
capacityReservationId =
          Text
pCapacityReservationId_
      }

-- | 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@.
getCapacityReservationUsage_dryRun :: Lens.Lens' GetCapacityReservationUsage (Prelude.Maybe Prelude.Bool)
getCapacityReservationUsage_dryRun :: Lens' GetCapacityReservationUsage (Maybe Bool)
getCapacityReservationUsage_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsage' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: GetCapacityReservationUsage
s@GetCapacityReservationUsage' {} Maybe Bool
a -> GetCapacityReservationUsage
s {$sel:dryRun:GetCapacityReservationUsage' :: Maybe Bool
dryRun = Maybe Bool
a} :: GetCapacityReservationUsage)

-- | The maximum number of results to return for the request in a single
-- page. The remaining results can be seen by sending another request with
-- the returned @nextToken@ value. This value can be between 5 and 500. If
-- @maxResults@ is given a larger value than 500, you receive an error.
--
-- Valid range: Minimum value of 1. Maximum value of 1000.
getCapacityReservationUsage_maxResults :: Lens.Lens' GetCapacityReservationUsage (Prelude.Maybe Prelude.Natural)
getCapacityReservationUsage_maxResults :: Lens' GetCapacityReservationUsage (Maybe Natural)
getCapacityReservationUsage_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsage' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: GetCapacityReservationUsage
s@GetCapacityReservationUsage' {} Maybe Natural
a -> GetCapacityReservationUsage
s {$sel:maxResults:GetCapacityReservationUsage' :: Maybe Natural
maxResults = Maybe Natural
a} :: GetCapacityReservationUsage)

-- | The token to use to retrieve the next page of results.
getCapacityReservationUsage_nextToken :: Lens.Lens' GetCapacityReservationUsage (Prelude.Maybe Prelude.Text)
getCapacityReservationUsage_nextToken :: Lens' GetCapacityReservationUsage (Maybe Text)
getCapacityReservationUsage_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsage' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetCapacityReservationUsage
s@GetCapacityReservationUsage' {} Maybe Text
a -> GetCapacityReservationUsage
s {$sel:nextToken:GetCapacityReservationUsage' :: Maybe Text
nextToken = Maybe Text
a} :: GetCapacityReservationUsage)

-- | The ID of the Capacity Reservation.
getCapacityReservationUsage_capacityReservationId :: Lens.Lens' GetCapacityReservationUsage Prelude.Text
getCapacityReservationUsage_capacityReservationId :: Lens' GetCapacityReservationUsage Text
getCapacityReservationUsage_capacityReservationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsage' {Text
capacityReservationId :: Text
$sel:capacityReservationId:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Text
capacityReservationId} -> Text
capacityReservationId) (\s :: GetCapacityReservationUsage
s@GetCapacityReservationUsage' {} Text
a -> GetCapacityReservationUsage
s {$sel:capacityReservationId:GetCapacityReservationUsage' :: Text
capacityReservationId = Text
a} :: GetCapacityReservationUsage)

instance Core.AWSRequest GetCapacityReservationUsage where
  type
    AWSResponse GetCapacityReservationUsage =
      GetCapacityReservationUsageResponse
  request :: (Service -> Service)
-> GetCapacityReservationUsage
-> Request GetCapacityReservationUsage
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 GetCapacityReservationUsage
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetCapacityReservationUsage)))
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 Int
-> Maybe Text
-> Maybe Text
-> Maybe [InstanceUsage]
-> Maybe Text
-> Maybe CapacityReservationState
-> Maybe Int
-> Int
-> GetCapacityReservationUsageResponse
GetCapacityReservationUsageResponse'
            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
"availableInstanceCount")
            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
"capacityReservationId")
            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
"instanceUsageSet"
                            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
"nextToken")
            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
"totalInstanceCount")
            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 GetCapacityReservationUsage where
  hashWithSalt :: Int -> GetCapacityReservationUsage -> Int
hashWithSalt Int
_salt GetCapacityReservationUsage' {Maybe Bool
Maybe Natural
Maybe Text
Text
capacityReservationId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
dryRun :: Maybe Bool
$sel:capacityReservationId:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Text
$sel:nextToken:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Text
$sel:maxResults:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Natural
$sel:dryRun:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
capacityReservationId

instance Prelude.NFData GetCapacityReservationUsage where
  rnf :: GetCapacityReservationUsage -> ()
rnf GetCapacityReservationUsage' {Maybe Bool
Maybe Natural
Maybe Text
Text
capacityReservationId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
dryRun :: Maybe Bool
$sel:capacityReservationId:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Text
$sel:nextToken:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Text
$sel:maxResults:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Natural
$sel:dryRun:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Bool
..} =
    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 Natural
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
capacityReservationId

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

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

instance Data.ToQuery GetCapacityReservationUsage where
  toQuery :: GetCapacityReservationUsage -> QueryString
toQuery GetCapacityReservationUsage' {Maybe Bool
Maybe Natural
Maybe Text
Text
capacityReservationId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
dryRun :: Maybe Bool
$sel:capacityReservationId:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Text
$sel:nextToken:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Text
$sel:maxResults:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Natural
$sel:dryRun:GetCapacityReservationUsage' :: GetCapacityReservationUsage -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"GetCapacityReservationUsage" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"MaxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"NextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"CapacityReservationId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
capacityReservationId
      ]

-- | /See:/ 'newGetCapacityReservationUsageResponse' smart constructor.
data GetCapacityReservationUsageResponse = GetCapacityReservationUsageResponse'
  { -- | The remaining capacity. Indicates the number of instances that can be
    -- launched in the Capacity Reservation.
    GetCapacityReservationUsageResponse -> Maybe Int
availableInstanceCount :: Prelude.Maybe Prelude.Int,
    -- | The ID of the Capacity Reservation.
    GetCapacityReservationUsageResponse -> Maybe Text
capacityReservationId :: Prelude.Maybe Prelude.Text,
    -- | The type of instance for which the Capacity Reservation reserves
    -- capacity.
    GetCapacityReservationUsageResponse -> Maybe Text
instanceType :: Prelude.Maybe Prelude.Text,
    -- | Information about the Capacity Reservation usage.
    GetCapacityReservationUsageResponse -> Maybe [InstanceUsage]
instanceUsages :: Prelude.Maybe [InstanceUsage],
    -- | The token to use to retrieve the next page of results. This value is
    -- @null@ when there are no more results to return.
    GetCapacityReservationUsageResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The current state of the Capacity Reservation. A Capacity Reservation
    -- can be in one of the following states:
    --
    -- -   @active@ - The Capacity Reservation is active and the capacity is
    --     available for your use.
    --
    -- -   @expired@ - The Capacity Reservation expired automatically at the
    --     date and time specified in your request. The reserved capacity is no
    --     longer available for your use.
    --
    -- -   @cancelled@ - The Capacity Reservation was cancelled. The reserved
    --     capacity is no longer available for your use.
    --
    -- -   @pending@ - The Capacity Reservation request was successful but the
    --     capacity provisioning is still pending.
    --
    -- -   @failed@ - The Capacity Reservation request has failed. A request
    --     might fail due to invalid request parameters, capacity constraints,
    --     or instance limit constraints. Failed requests are retained for 60
    --     minutes.
    GetCapacityReservationUsageResponse
-> Maybe CapacityReservationState
state :: Prelude.Maybe CapacityReservationState,
    -- | The number of instances for which the Capacity Reservation reserves
    -- capacity.
    GetCapacityReservationUsageResponse -> Maybe Int
totalInstanceCount :: Prelude.Maybe Prelude.Int,
    -- | The response's http status code.
    GetCapacityReservationUsageResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetCapacityReservationUsageResponse
-> GetCapacityReservationUsageResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetCapacityReservationUsageResponse
-> GetCapacityReservationUsageResponse -> Bool
$c/= :: GetCapacityReservationUsageResponse
-> GetCapacityReservationUsageResponse -> Bool
== :: GetCapacityReservationUsageResponse
-> GetCapacityReservationUsageResponse -> Bool
$c== :: GetCapacityReservationUsageResponse
-> GetCapacityReservationUsageResponse -> Bool
Prelude.Eq, ReadPrec [GetCapacityReservationUsageResponse]
ReadPrec GetCapacityReservationUsageResponse
Int -> ReadS GetCapacityReservationUsageResponse
ReadS [GetCapacityReservationUsageResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetCapacityReservationUsageResponse]
$creadListPrec :: ReadPrec [GetCapacityReservationUsageResponse]
readPrec :: ReadPrec GetCapacityReservationUsageResponse
$creadPrec :: ReadPrec GetCapacityReservationUsageResponse
readList :: ReadS [GetCapacityReservationUsageResponse]
$creadList :: ReadS [GetCapacityReservationUsageResponse]
readsPrec :: Int -> ReadS GetCapacityReservationUsageResponse
$creadsPrec :: Int -> ReadS GetCapacityReservationUsageResponse
Prelude.Read, Int -> GetCapacityReservationUsageResponse -> ShowS
[GetCapacityReservationUsageResponse] -> ShowS
GetCapacityReservationUsageResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetCapacityReservationUsageResponse] -> ShowS
$cshowList :: [GetCapacityReservationUsageResponse] -> ShowS
show :: GetCapacityReservationUsageResponse -> String
$cshow :: GetCapacityReservationUsageResponse -> String
showsPrec :: Int -> GetCapacityReservationUsageResponse -> ShowS
$cshowsPrec :: Int -> GetCapacityReservationUsageResponse -> ShowS
Prelude.Show, forall x.
Rep GetCapacityReservationUsageResponse x
-> GetCapacityReservationUsageResponse
forall x.
GetCapacityReservationUsageResponse
-> Rep GetCapacityReservationUsageResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetCapacityReservationUsageResponse x
-> GetCapacityReservationUsageResponse
$cfrom :: forall x.
GetCapacityReservationUsageResponse
-> Rep GetCapacityReservationUsageResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetCapacityReservationUsageResponse' 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:
--
-- 'availableInstanceCount', 'getCapacityReservationUsageResponse_availableInstanceCount' - The remaining capacity. Indicates the number of instances that can be
-- launched in the Capacity Reservation.
--
-- 'capacityReservationId', 'getCapacityReservationUsageResponse_capacityReservationId' - The ID of the Capacity Reservation.
--
-- 'instanceType', 'getCapacityReservationUsageResponse_instanceType' - The type of instance for which the Capacity Reservation reserves
-- capacity.
--
-- 'instanceUsages', 'getCapacityReservationUsageResponse_instanceUsages' - Information about the Capacity Reservation usage.
--
-- 'nextToken', 'getCapacityReservationUsageResponse_nextToken' - The token to use to retrieve the next page of results. This value is
-- @null@ when there are no more results to return.
--
-- 'state', 'getCapacityReservationUsageResponse_state' - The current state of the Capacity Reservation. A Capacity Reservation
-- can be in one of the following states:
--
-- -   @active@ - The Capacity Reservation is active and the capacity is
--     available for your use.
--
-- -   @expired@ - The Capacity Reservation expired automatically at the
--     date and time specified in your request. The reserved capacity is no
--     longer available for your use.
--
-- -   @cancelled@ - The Capacity Reservation was cancelled. The reserved
--     capacity is no longer available for your use.
--
-- -   @pending@ - The Capacity Reservation request was successful but the
--     capacity provisioning is still pending.
--
-- -   @failed@ - The Capacity Reservation request has failed. A request
--     might fail due to invalid request parameters, capacity constraints,
--     or instance limit constraints. Failed requests are retained for 60
--     minutes.
--
-- 'totalInstanceCount', 'getCapacityReservationUsageResponse_totalInstanceCount' - The number of instances for which the Capacity Reservation reserves
-- capacity.
--
-- 'httpStatus', 'getCapacityReservationUsageResponse_httpStatus' - The response's http status code.
newGetCapacityReservationUsageResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetCapacityReservationUsageResponse
newGetCapacityReservationUsageResponse :: Int -> GetCapacityReservationUsageResponse
newGetCapacityReservationUsageResponse Int
pHttpStatus_ =
  GetCapacityReservationUsageResponse'
    { $sel:availableInstanceCount:GetCapacityReservationUsageResponse' :: Maybe Int
availableInstanceCount =
        forall a. Maybe a
Prelude.Nothing,
      $sel:capacityReservationId:GetCapacityReservationUsageResponse' :: Maybe Text
capacityReservationId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:instanceType:GetCapacityReservationUsageResponse' :: Maybe Text
instanceType = forall a. Maybe a
Prelude.Nothing,
      $sel:instanceUsages:GetCapacityReservationUsageResponse' :: Maybe [InstanceUsage]
instanceUsages = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:GetCapacityReservationUsageResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:state:GetCapacityReservationUsageResponse' :: Maybe CapacityReservationState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:totalInstanceCount:GetCapacityReservationUsageResponse' :: Maybe Int
totalInstanceCount = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetCapacityReservationUsageResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The remaining capacity. Indicates the number of instances that can be
-- launched in the Capacity Reservation.
getCapacityReservationUsageResponse_availableInstanceCount :: Lens.Lens' GetCapacityReservationUsageResponse (Prelude.Maybe Prelude.Int)
getCapacityReservationUsageResponse_availableInstanceCount :: Lens' GetCapacityReservationUsageResponse (Maybe Int)
getCapacityReservationUsageResponse_availableInstanceCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsageResponse' {Maybe Int
availableInstanceCount :: Maybe Int
$sel:availableInstanceCount:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Int
availableInstanceCount} -> Maybe Int
availableInstanceCount) (\s :: GetCapacityReservationUsageResponse
s@GetCapacityReservationUsageResponse' {} Maybe Int
a -> GetCapacityReservationUsageResponse
s {$sel:availableInstanceCount:GetCapacityReservationUsageResponse' :: Maybe Int
availableInstanceCount = Maybe Int
a} :: GetCapacityReservationUsageResponse)

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

-- | The type of instance for which the Capacity Reservation reserves
-- capacity.
getCapacityReservationUsageResponse_instanceType :: Lens.Lens' GetCapacityReservationUsageResponse (Prelude.Maybe Prelude.Text)
getCapacityReservationUsageResponse_instanceType :: Lens' GetCapacityReservationUsageResponse (Maybe Text)
getCapacityReservationUsageResponse_instanceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsageResponse' {Maybe Text
instanceType :: Maybe Text
$sel:instanceType:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Text
instanceType} -> Maybe Text
instanceType) (\s :: GetCapacityReservationUsageResponse
s@GetCapacityReservationUsageResponse' {} Maybe Text
a -> GetCapacityReservationUsageResponse
s {$sel:instanceType:GetCapacityReservationUsageResponse' :: Maybe Text
instanceType = Maybe Text
a} :: GetCapacityReservationUsageResponse)

-- | Information about the Capacity Reservation usage.
getCapacityReservationUsageResponse_instanceUsages :: Lens.Lens' GetCapacityReservationUsageResponse (Prelude.Maybe [InstanceUsage])
getCapacityReservationUsageResponse_instanceUsages :: Lens' GetCapacityReservationUsageResponse (Maybe [InstanceUsage])
getCapacityReservationUsageResponse_instanceUsages = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsageResponse' {Maybe [InstanceUsage]
instanceUsages :: Maybe [InstanceUsage]
$sel:instanceUsages:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe [InstanceUsage]
instanceUsages} -> Maybe [InstanceUsage]
instanceUsages) (\s :: GetCapacityReservationUsageResponse
s@GetCapacityReservationUsageResponse' {} Maybe [InstanceUsage]
a -> GetCapacityReservationUsageResponse
s {$sel:instanceUsages:GetCapacityReservationUsageResponse' :: Maybe [InstanceUsage]
instanceUsages = Maybe [InstanceUsage]
a} :: GetCapacityReservationUsageResponse) 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 token to use to retrieve the next page of results. This value is
-- @null@ when there are no more results to return.
getCapacityReservationUsageResponse_nextToken :: Lens.Lens' GetCapacityReservationUsageResponse (Prelude.Maybe Prelude.Text)
getCapacityReservationUsageResponse_nextToken :: Lens' GetCapacityReservationUsageResponse (Maybe Text)
getCapacityReservationUsageResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsageResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetCapacityReservationUsageResponse
s@GetCapacityReservationUsageResponse' {} Maybe Text
a -> GetCapacityReservationUsageResponse
s {$sel:nextToken:GetCapacityReservationUsageResponse' :: Maybe Text
nextToken = Maybe Text
a} :: GetCapacityReservationUsageResponse)

-- | The current state of the Capacity Reservation. A Capacity Reservation
-- can be in one of the following states:
--
-- -   @active@ - The Capacity Reservation is active and the capacity is
--     available for your use.
--
-- -   @expired@ - The Capacity Reservation expired automatically at the
--     date and time specified in your request. The reserved capacity is no
--     longer available for your use.
--
-- -   @cancelled@ - The Capacity Reservation was cancelled. The reserved
--     capacity is no longer available for your use.
--
-- -   @pending@ - The Capacity Reservation request was successful but the
--     capacity provisioning is still pending.
--
-- -   @failed@ - The Capacity Reservation request has failed. A request
--     might fail due to invalid request parameters, capacity constraints,
--     or instance limit constraints. Failed requests are retained for 60
--     minutes.
getCapacityReservationUsageResponse_state :: Lens.Lens' GetCapacityReservationUsageResponse (Prelude.Maybe CapacityReservationState)
getCapacityReservationUsageResponse_state :: Lens'
  GetCapacityReservationUsageResponse
  (Maybe CapacityReservationState)
getCapacityReservationUsageResponse_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsageResponse' {Maybe CapacityReservationState
state :: Maybe CapacityReservationState
$sel:state:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse
-> Maybe CapacityReservationState
state} -> Maybe CapacityReservationState
state) (\s :: GetCapacityReservationUsageResponse
s@GetCapacityReservationUsageResponse' {} Maybe CapacityReservationState
a -> GetCapacityReservationUsageResponse
s {$sel:state:GetCapacityReservationUsageResponse' :: Maybe CapacityReservationState
state = Maybe CapacityReservationState
a} :: GetCapacityReservationUsageResponse)

-- | The number of instances for which the Capacity Reservation reserves
-- capacity.
getCapacityReservationUsageResponse_totalInstanceCount :: Lens.Lens' GetCapacityReservationUsageResponse (Prelude.Maybe Prelude.Int)
getCapacityReservationUsageResponse_totalInstanceCount :: Lens' GetCapacityReservationUsageResponse (Maybe Int)
getCapacityReservationUsageResponse_totalInstanceCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetCapacityReservationUsageResponse' {Maybe Int
totalInstanceCount :: Maybe Int
$sel:totalInstanceCount:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Int
totalInstanceCount} -> Maybe Int
totalInstanceCount) (\s :: GetCapacityReservationUsageResponse
s@GetCapacityReservationUsageResponse' {} Maybe Int
a -> GetCapacityReservationUsageResponse
s {$sel:totalInstanceCount:GetCapacityReservationUsageResponse' :: Maybe Int
totalInstanceCount = Maybe Int
a} :: GetCapacityReservationUsageResponse)

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

instance
  Prelude.NFData
    GetCapacityReservationUsageResponse
  where
  rnf :: GetCapacityReservationUsageResponse -> ()
rnf GetCapacityReservationUsageResponse' {Int
Maybe Int
Maybe [InstanceUsage]
Maybe Text
Maybe CapacityReservationState
httpStatus :: Int
totalInstanceCount :: Maybe Int
state :: Maybe CapacityReservationState
nextToken :: Maybe Text
instanceUsages :: Maybe [InstanceUsage]
instanceType :: Maybe Text
capacityReservationId :: Maybe Text
availableInstanceCount :: Maybe Int
$sel:httpStatus:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Int
$sel:totalInstanceCount:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Int
$sel:state:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse
-> Maybe CapacityReservationState
$sel:nextToken:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Text
$sel:instanceUsages:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe [InstanceUsage]
$sel:instanceType:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Text
$sel:capacityReservationId:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Text
$sel:availableInstanceCount:GetCapacityReservationUsageResponse' :: GetCapacityReservationUsageResponse -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
availableInstanceCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
capacityReservationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
instanceType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [InstanceUsage]
instanceUsages
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CapacityReservationState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
totalInstanceCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus