{-# 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.CostExplorer.GetReservationCoverage
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves the reservation coverage for your account, which you can use
-- to see how much of your Amazon Elastic Compute Cloud, Amazon
-- ElastiCache, Amazon Relational Database Service, or Amazon Redshift
-- usage is covered by a reservation. An organization\'s management account
-- can see the coverage of the associated member accounts. This supports
-- dimensions, Cost Categories, and nested expressions. For any time
-- period, you can filter data about reservation usage by the following
-- dimensions:
--
-- -   AZ
--
-- -   CACHE_ENGINE
--
-- -   DATABASE_ENGINE
--
-- -   DEPLOYMENT_OPTION
--
-- -   INSTANCE_TYPE
--
-- -   LINKED_ACCOUNT
--
-- -   OPERATING_SYSTEM
--
-- -   PLATFORM
--
-- -   REGION
--
-- -   SERVICE
--
-- -   TAG
--
-- -   TENANCY
--
-- To determine valid values for a dimension, use the @GetDimensionValues@
-- operation.
module Amazonka.CostExplorer.GetReservationCoverage
  ( -- * Creating a Request
    GetReservationCoverage (..),
    newGetReservationCoverage,

    -- * Request Lenses
    getReservationCoverage_filter,
    getReservationCoverage_granularity,
    getReservationCoverage_groupBy,
    getReservationCoverage_maxResults,
    getReservationCoverage_metrics,
    getReservationCoverage_nextPageToken,
    getReservationCoverage_sortBy,
    getReservationCoverage_timePeriod,

    -- * Destructuring the Response
    GetReservationCoverageResponse (..),
    newGetReservationCoverageResponse,

    -- * Response Lenses
    getReservationCoverageResponse_nextPageToken,
    getReservationCoverageResponse_total,
    getReservationCoverageResponse_httpStatus,
    getReservationCoverageResponse_coveragesByTime,
  )
where

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

-- | You can use the following request parameters to query for how much of
-- your instance usage a reservation covered.
--
-- /See:/ 'newGetReservationCoverage' smart constructor.
data GetReservationCoverage = GetReservationCoverage'
  { -- | Filters utilization data by dimensions. You can filter by the following
    -- dimensions:
    --
    -- -   AZ
    --
    -- -   CACHE_ENGINE
    --
    -- -   DATABASE_ENGINE
    --
    -- -   DEPLOYMENT_OPTION
    --
    -- -   INSTANCE_TYPE
    --
    -- -   LINKED_ACCOUNT
    --
    -- -   OPERATING_SYSTEM
    --
    -- -   PLATFORM
    --
    -- -   REGION
    --
    -- -   SERVICE
    --
    -- -   TAG
    --
    -- -   TENANCY
    --
    -- @GetReservationCoverage@ uses the same
    -- <https://docs.aws.amazon.com/aws-cost-management/latest/APIReference/API_Expression.html Expression>
    -- object as the other operations, but only @AND@ is supported among each
    -- dimension. You can nest only one level deep. If there are multiple
    -- values for a dimension, they are OR\'d together.
    --
    -- If you don\'t provide a @SERVICE@ filter, Cost Explorer defaults to EC2.
    --
    -- Cost category is also supported.
    GetReservationCoverage -> Maybe Expression
filter' :: Prelude.Maybe Expression,
    -- | The granularity of the Amazon Web Services cost data for the
    -- reservation. Valid values are @MONTHLY@ and @DAILY@.
    --
    -- If @GroupBy@ is set, @Granularity@ can\'t be set. If @Granularity@
    -- isn\'t set, the response object doesn\'t include @Granularity@, either
    -- @MONTHLY@ or @DAILY@.
    --
    -- The @GetReservationCoverage@ operation supports only @DAILY@ and
    -- @MONTHLY@ granularities.
    GetReservationCoverage -> Maybe Granularity
granularity :: Prelude.Maybe Granularity,
    -- | You can group the data by the following attributes:
    --
    -- -   AZ
    --
    -- -   CACHE_ENGINE
    --
    -- -   DATABASE_ENGINE
    --
    -- -   DEPLOYMENT_OPTION
    --
    -- -   INSTANCE_TYPE
    --
    -- -   INVOICING_ENTITY
    --
    -- -   LINKED_ACCOUNT
    --
    -- -   OPERATING_SYSTEM
    --
    -- -   PLATFORM
    --
    -- -   REGION
    --
    -- -   TENANCY
    GetReservationCoverage -> Maybe [GroupDefinition]
groupBy :: Prelude.Maybe [GroupDefinition],
    -- | The maximum number of objects that you returned for this request. If
    -- more objects are available, in the response, Amazon Web Services
    -- provides a NextPageToken value that you can use in a subsequent call to
    -- get the next batch of objects.
    GetReservationCoverage -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The measurement that you want your reservation coverage reported in.
    --
    -- Valid values are @Hour@, @Unit@, and @Cost@. You can use multiple values
    -- in a request.
    GetReservationCoverage -> Maybe [Text]
metrics :: Prelude.Maybe [Prelude.Text],
    -- | The token to retrieve the next set of results. Amazon Web Services
    -- provides the token when the response from a previous call has more
    -- results than the maximum page size.
    GetReservationCoverage -> Maybe Text
nextPageToken :: Prelude.Maybe Prelude.Text,
    -- | The value by which you want to sort the data.
    --
    -- The following values are supported for @Key@:
    --
    -- -   @OnDemandCost@
    --
    -- -   @CoverageHoursPercentage@
    --
    -- -   @OnDemandHours@
    --
    -- -   @ReservedHours@
    --
    -- -   @TotalRunningHours@
    --
    -- -   @CoverageNormalizedUnitsPercentage@
    --
    -- -   @OnDemandNormalizedUnits@
    --
    -- -   @ReservedNormalizedUnits@
    --
    -- -   @TotalRunningNormalizedUnits@
    --
    -- -   @Time@
    --
    -- Supported values for @SortOrder@ are @ASCENDING@ or @DESCENDING@.
    GetReservationCoverage -> Maybe SortDefinition
sortBy :: Prelude.Maybe SortDefinition,
    -- | The start and end dates of the period that you want to retrieve data
    -- about reservation coverage for. You can retrieve data for a maximum of
    -- 13 months: the last 12 months and the current month. The start date is
    -- inclusive, but the end date is exclusive. For example, if @start@ is
    -- @2017-01-01@ and @end@ is @2017-05-01@, then the cost and usage data is
    -- retrieved from @2017-01-01@ up to and including @2017-04-30@ but not
    -- including @2017-05-01@.
    GetReservationCoverage -> DateInterval
timePeriod :: DateInterval
  }
  deriving (GetReservationCoverage -> GetReservationCoverage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetReservationCoverage -> GetReservationCoverage -> Bool
$c/= :: GetReservationCoverage -> GetReservationCoverage -> Bool
== :: GetReservationCoverage -> GetReservationCoverage -> Bool
$c== :: GetReservationCoverage -> GetReservationCoverage -> Bool
Prelude.Eq, ReadPrec [GetReservationCoverage]
ReadPrec GetReservationCoverage
Int -> ReadS GetReservationCoverage
ReadS [GetReservationCoverage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetReservationCoverage]
$creadListPrec :: ReadPrec [GetReservationCoverage]
readPrec :: ReadPrec GetReservationCoverage
$creadPrec :: ReadPrec GetReservationCoverage
readList :: ReadS [GetReservationCoverage]
$creadList :: ReadS [GetReservationCoverage]
readsPrec :: Int -> ReadS GetReservationCoverage
$creadsPrec :: Int -> ReadS GetReservationCoverage
Prelude.Read, Int -> GetReservationCoverage -> ShowS
[GetReservationCoverage] -> ShowS
GetReservationCoverage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetReservationCoverage] -> ShowS
$cshowList :: [GetReservationCoverage] -> ShowS
show :: GetReservationCoverage -> String
$cshow :: GetReservationCoverage -> String
showsPrec :: Int -> GetReservationCoverage -> ShowS
$cshowsPrec :: Int -> GetReservationCoverage -> ShowS
Prelude.Show, forall x. Rep GetReservationCoverage x -> GetReservationCoverage
forall x. GetReservationCoverage -> Rep GetReservationCoverage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetReservationCoverage x -> GetReservationCoverage
$cfrom :: forall x. GetReservationCoverage -> Rep GetReservationCoverage x
Prelude.Generic)

-- |
-- Create a value of 'GetReservationCoverage' 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:
--
-- 'filter'', 'getReservationCoverage_filter' - Filters utilization data by dimensions. You can filter by the following
-- dimensions:
--
-- -   AZ
--
-- -   CACHE_ENGINE
--
-- -   DATABASE_ENGINE
--
-- -   DEPLOYMENT_OPTION
--
-- -   INSTANCE_TYPE
--
-- -   LINKED_ACCOUNT
--
-- -   OPERATING_SYSTEM
--
-- -   PLATFORM
--
-- -   REGION
--
-- -   SERVICE
--
-- -   TAG
--
-- -   TENANCY
--
-- @GetReservationCoverage@ uses the same
-- <https://docs.aws.amazon.com/aws-cost-management/latest/APIReference/API_Expression.html Expression>
-- object as the other operations, but only @AND@ is supported among each
-- dimension. You can nest only one level deep. If there are multiple
-- values for a dimension, they are OR\'d together.
--
-- If you don\'t provide a @SERVICE@ filter, Cost Explorer defaults to EC2.
--
-- Cost category is also supported.
--
-- 'granularity', 'getReservationCoverage_granularity' - The granularity of the Amazon Web Services cost data for the
-- reservation. Valid values are @MONTHLY@ and @DAILY@.
--
-- If @GroupBy@ is set, @Granularity@ can\'t be set. If @Granularity@
-- isn\'t set, the response object doesn\'t include @Granularity@, either
-- @MONTHLY@ or @DAILY@.
--
-- The @GetReservationCoverage@ operation supports only @DAILY@ and
-- @MONTHLY@ granularities.
--
-- 'groupBy', 'getReservationCoverage_groupBy' - You can group the data by the following attributes:
--
-- -   AZ
--
-- -   CACHE_ENGINE
--
-- -   DATABASE_ENGINE
--
-- -   DEPLOYMENT_OPTION
--
-- -   INSTANCE_TYPE
--
-- -   INVOICING_ENTITY
--
-- -   LINKED_ACCOUNT
--
-- -   OPERATING_SYSTEM
--
-- -   PLATFORM
--
-- -   REGION
--
-- -   TENANCY
--
-- 'maxResults', 'getReservationCoverage_maxResults' - The maximum number of objects that you returned for this request. If
-- more objects are available, in the response, Amazon Web Services
-- provides a NextPageToken value that you can use in a subsequent call to
-- get the next batch of objects.
--
-- 'metrics', 'getReservationCoverage_metrics' - The measurement that you want your reservation coverage reported in.
--
-- Valid values are @Hour@, @Unit@, and @Cost@. You can use multiple values
-- in a request.
--
-- 'nextPageToken', 'getReservationCoverage_nextPageToken' - The token to retrieve the next set of results. Amazon Web Services
-- provides the token when the response from a previous call has more
-- results than the maximum page size.
--
-- 'sortBy', 'getReservationCoverage_sortBy' - The value by which you want to sort the data.
--
-- The following values are supported for @Key@:
--
-- -   @OnDemandCost@
--
-- -   @CoverageHoursPercentage@
--
-- -   @OnDemandHours@
--
-- -   @ReservedHours@
--
-- -   @TotalRunningHours@
--
-- -   @CoverageNormalizedUnitsPercentage@
--
-- -   @OnDemandNormalizedUnits@
--
-- -   @ReservedNormalizedUnits@
--
-- -   @TotalRunningNormalizedUnits@
--
-- -   @Time@
--
-- Supported values for @SortOrder@ are @ASCENDING@ or @DESCENDING@.
--
-- 'timePeriod', 'getReservationCoverage_timePeriod' - The start and end dates of the period that you want to retrieve data
-- about reservation coverage for. You can retrieve data for a maximum of
-- 13 months: the last 12 months and the current month. The start date is
-- inclusive, but the end date is exclusive. For example, if @start@ is
-- @2017-01-01@ and @end@ is @2017-05-01@, then the cost and usage data is
-- retrieved from @2017-01-01@ up to and including @2017-04-30@ but not
-- including @2017-05-01@.
newGetReservationCoverage ::
  -- | 'timePeriod'
  DateInterval ->
  GetReservationCoverage
newGetReservationCoverage :: DateInterval -> GetReservationCoverage
newGetReservationCoverage DateInterval
pTimePeriod_ =
  GetReservationCoverage'
    { $sel:filter':GetReservationCoverage' :: Maybe Expression
filter' = forall a. Maybe a
Prelude.Nothing,
      $sel:granularity:GetReservationCoverage' :: Maybe Granularity
granularity = forall a. Maybe a
Prelude.Nothing,
      $sel:groupBy:GetReservationCoverage' :: Maybe [GroupDefinition]
groupBy = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:GetReservationCoverage' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:metrics:GetReservationCoverage' :: Maybe [Text]
metrics = forall a. Maybe a
Prelude.Nothing,
      $sel:nextPageToken:GetReservationCoverage' :: Maybe Text
nextPageToken = forall a. Maybe a
Prelude.Nothing,
      $sel:sortBy:GetReservationCoverage' :: Maybe SortDefinition
sortBy = forall a. Maybe a
Prelude.Nothing,
      $sel:timePeriod:GetReservationCoverage' :: DateInterval
timePeriod = DateInterval
pTimePeriod_
    }

-- | Filters utilization data by dimensions. You can filter by the following
-- dimensions:
--
-- -   AZ
--
-- -   CACHE_ENGINE
--
-- -   DATABASE_ENGINE
--
-- -   DEPLOYMENT_OPTION
--
-- -   INSTANCE_TYPE
--
-- -   LINKED_ACCOUNT
--
-- -   OPERATING_SYSTEM
--
-- -   PLATFORM
--
-- -   REGION
--
-- -   SERVICE
--
-- -   TAG
--
-- -   TENANCY
--
-- @GetReservationCoverage@ uses the same
-- <https://docs.aws.amazon.com/aws-cost-management/latest/APIReference/API_Expression.html Expression>
-- object as the other operations, but only @AND@ is supported among each
-- dimension. You can nest only one level deep. If there are multiple
-- values for a dimension, they are OR\'d together.
--
-- If you don\'t provide a @SERVICE@ filter, Cost Explorer defaults to EC2.
--
-- Cost category is also supported.
getReservationCoverage_filter :: Lens.Lens' GetReservationCoverage (Prelude.Maybe Expression)
getReservationCoverage_filter :: Lens' GetReservationCoverage (Maybe Expression)
getReservationCoverage_filter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe Expression
filter' :: Maybe Expression
$sel:filter':GetReservationCoverage' :: GetReservationCoverage -> Maybe Expression
filter'} -> Maybe Expression
filter') (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe Expression
a -> GetReservationCoverage
s {$sel:filter':GetReservationCoverage' :: Maybe Expression
filter' = Maybe Expression
a} :: GetReservationCoverage)

-- | The granularity of the Amazon Web Services cost data for the
-- reservation. Valid values are @MONTHLY@ and @DAILY@.
--
-- If @GroupBy@ is set, @Granularity@ can\'t be set. If @Granularity@
-- isn\'t set, the response object doesn\'t include @Granularity@, either
-- @MONTHLY@ or @DAILY@.
--
-- The @GetReservationCoverage@ operation supports only @DAILY@ and
-- @MONTHLY@ granularities.
getReservationCoverage_granularity :: Lens.Lens' GetReservationCoverage (Prelude.Maybe Granularity)
getReservationCoverage_granularity :: Lens' GetReservationCoverage (Maybe Granularity)
getReservationCoverage_granularity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe Granularity
granularity :: Maybe Granularity
$sel:granularity:GetReservationCoverage' :: GetReservationCoverage -> Maybe Granularity
granularity} -> Maybe Granularity
granularity) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe Granularity
a -> GetReservationCoverage
s {$sel:granularity:GetReservationCoverage' :: Maybe Granularity
granularity = Maybe Granularity
a} :: GetReservationCoverage)

-- | You can group the data by the following attributes:
--
-- -   AZ
--
-- -   CACHE_ENGINE
--
-- -   DATABASE_ENGINE
--
-- -   DEPLOYMENT_OPTION
--
-- -   INSTANCE_TYPE
--
-- -   INVOICING_ENTITY
--
-- -   LINKED_ACCOUNT
--
-- -   OPERATING_SYSTEM
--
-- -   PLATFORM
--
-- -   REGION
--
-- -   TENANCY
getReservationCoverage_groupBy :: Lens.Lens' GetReservationCoverage (Prelude.Maybe [GroupDefinition])
getReservationCoverage_groupBy :: Lens' GetReservationCoverage (Maybe [GroupDefinition])
getReservationCoverage_groupBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe [GroupDefinition]
groupBy :: Maybe [GroupDefinition]
$sel:groupBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe [GroupDefinition]
groupBy} -> Maybe [GroupDefinition]
groupBy) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe [GroupDefinition]
a -> GetReservationCoverage
s {$sel:groupBy:GetReservationCoverage' :: Maybe [GroupDefinition]
groupBy = Maybe [GroupDefinition]
a} :: GetReservationCoverage) 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 maximum number of objects that you returned for this request. If
-- more objects are available, in the response, Amazon Web Services
-- provides a NextPageToken value that you can use in a subsequent call to
-- get the next batch of objects.
getReservationCoverage_maxResults :: Lens.Lens' GetReservationCoverage (Prelude.Maybe Prelude.Natural)
getReservationCoverage_maxResults :: Lens' GetReservationCoverage (Maybe Natural)
getReservationCoverage_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:GetReservationCoverage' :: GetReservationCoverage -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe Natural
a -> GetReservationCoverage
s {$sel:maxResults:GetReservationCoverage' :: Maybe Natural
maxResults = Maybe Natural
a} :: GetReservationCoverage)

-- | The measurement that you want your reservation coverage reported in.
--
-- Valid values are @Hour@, @Unit@, and @Cost@. You can use multiple values
-- in a request.
getReservationCoverage_metrics :: Lens.Lens' GetReservationCoverage (Prelude.Maybe [Prelude.Text])
getReservationCoverage_metrics :: Lens' GetReservationCoverage (Maybe [Text])
getReservationCoverage_metrics = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe [Text]
metrics :: Maybe [Text]
$sel:metrics:GetReservationCoverage' :: GetReservationCoverage -> Maybe [Text]
metrics} -> Maybe [Text]
metrics) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe [Text]
a -> GetReservationCoverage
s {$sel:metrics:GetReservationCoverage' :: Maybe [Text]
metrics = Maybe [Text]
a} :: GetReservationCoverage) 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 retrieve the next set of results. Amazon Web Services
-- provides the token when the response from a previous call has more
-- results than the maximum page size.
getReservationCoverage_nextPageToken :: Lens.Lens' GetReservationCoverage (Prelude.Maybe Prelude.Text)
getReservationCoverage_nextPageToken :: Lens' GetReservationCoverage (Maybe Text)
getReservationCoverage_nextPageToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe Text
nextPageToken :: Maybe Text
$sel:nextPageToken:GetReservationCoverage' :: GetReservationCoverage -> Maybe Text
nextPageToken} -> Maybe Text
nextPageToken) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe Text
a -> GetReservationCoverage
s {$sel:nextPageToken:GetReservationCoverage' :: Maybe Text
nextPageToken = Maybe Text
a} :: GetReservationCoverage)

-- | The value by which you want to sort the data.
--
-- The following values are supported for @Key@:
--
-- -   @OnDemandCost@
--
-- -   @CoverageHoursPercentage@
--
-- -   @OnDemandHours@
--
-- -   @ReservedHours@
--
-- -   @TotalRunningHours@
--
-- -   @CoverageNormalizedUnitsPercentage@
--
-- -   @OnDemandNormalizedUnits@
--
-- -   @ReservedNormalizedUnits@
--
-- -   @TotalRunningNormalizedUnits@
--
-- -   @Time@
--
-- Supported values for @SortOrder@ are @ASCENDING@ or @DESCENDING@.
getReservationCoverage_sortBy :: Lens.Lens' GetReservationCoverage (Prelude.Maybe SortDefinition)
getReservationCoverage_sortBy :: Lens' GetReservationCoverage (Maybe SortDefinition)
getReservationCoverage_sortBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {Maybe SortDefinition
sortBy :: Maybe SortDefinition
$sel:sortBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe SortDefinition
sortBy} -> Maybe SortDefinition
sortBy) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} Maybe SortDefinition
a -> GetReservationCoverage
s {$sel:sortBy:GetReservationCoverage' :: Maybe SortDefinition
sortBy = Maybe SortDefinition
a} :: GetReservationCoverage)

-- | The start and end dates of the period that you want to retrieve data
-- about reservation coverage for. You can retrieve data for a maximum of
-- 13 months: the last 12 months and the current month. The start date is
-- inclusive, but the end date is exclusive. For example, if @start@ is
-- @2017-01-01@ and @end@ is @2017-05-01@, then the cost and usage data is
-- retrieved from @2017-01-01@ up to and including @2017-04-30@ but not
-- including @2017-05-01@.
getReservationCoverage_timePeriod :: Lens.Lens' GetReservationCoverage DateInterval
getReservationCoverage_timePeriod :: Lens' GetReservationCoverage DateInterval
getReservationCoverage_timePeriod = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverage' {DateInterval
timePeriod :: DateInterval
$sel:timePeriod:GetReservationCoverage' :: GetReservationCoverage -> DateInterval
timePeriod} -> DateInterval
timePeriod) (\s :: GetReservationCoverage
s@GetReservationCoverage' {} DateInterval
a -> GetReservationCoverage
s {$sel:timePeriod:GetReservationCoverage' :: DateInterval
timePeriod = DateInterval
a} :: GetReservationCoverage)

instance Core.AWSRequest GetReservationCoverage where
  type
    AWSResponse GetReservationCoverage =
      GetReservationCoverageResponse
  request :: (Service -> Service)
-> GetReservationCoverage -> Request GetReservationCoverage
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetReservationCoverage
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetReservationCoverage)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe Coverage
-> Int
-> [CoverageByTime]
-> GetReservationCoverageResponse
GetReservationCoverageResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"NextPageToken")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Total")
            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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"CoveragesByTime"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable GetReservationCoverage where
  hashWithSalt :: Int -> GetReservationCoverage -> Int
hashWithSalt Int
_salt GetReservationCoverage' {Maybe Natural
Maybe [Text]
Maybe [GroupDefinition]
Maybe Text
Maybe Granularity
Maybe SortDefinition
Maybe Expression
DateInterval
timePeriod :: DateInterval
sortBy :: Maybe SortDefinition
nextPageToken :: Maybe Text
metrics :: Maybe [Text]
maxResults :: Maybe Natural
groupBy :: Maybe [GroupDefinition]
granularity :: Maybe Granularity
filter' :: Maybe Expression
$sel:timePeriod:GetReservationCoverage' :: GetReservationCoverage -> DateInterval
$sel:sortBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe SortDefinition
$sel:nextPageToken:GetReservationCoverage' :: GetReservationCoverage -> Maybe Text
$sel:metrics:GetReservationCoverage' :: GetReservationCoverage -> Maybe [Text]
$sel:maxResults:GetReservationCoverage' :: GetReservationCoverage -> Maybe Natural
$sel:groupBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe [GroupDefinition]
$sel:granularity:GetReservationCoverage' :: GetReservationCoverage -> Maybe Granularity
$sel:filter':GetReservationCoverage' :: GetReservationCoverage -> Maybe Expression
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Expression
filter'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Granularity
granularity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [GroupDefinition]
groupBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
metrics
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextPageToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SortDefinition
sortBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` DateInterval
timePeriod

instance Prelude.NFData GetReservationCoverage where
  rnf :: GetReservationCoverage -> ()
rnf GetReservationCoverage' {Maybe Natural
Maybe [Text]
Maybe [GroupDefinition]
Maybe Text
Maybe Granularity
Maybe SortDefinition
Maybe Expression
DateInterval
timePeriod :: DateInterval
sortBy :: Maybe SortDefinition
nextPageToken :: Maybe Text
metrics :: Maybe [Text]
maxResults :: Maybe Natural
groupBy :: Maybe [GroupDefinition]
granularity :: Maybe Granularity
filter' :: Maybe Expression
$sel:timePeriod:GetReservationCoverage' :: GetReservationCoverage -> DateInterval
$sel:sortBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe SortDefinition
$sel:nextPageToken:GetReservationCoverage' :: GetReservationCoverage -> Maybe Text
$sel:metrics:GetReservationCoverage' :: GetReservationCoverage -> Maybe [Text]
$sel:maxResults:GetReservationCoverage' :: GetReservationCoverage -> Maybe Natural
$sel:groupBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe [GroupDefinition]
$sel:granularity:GetReservationCoverage' :: GetReservationCoverage -> Maybe Granularity
$sel:filter':GetReservationCoverage' :: GetReservationCoverage -> Maybe Expression
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Expression
filter'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Granularity
granularity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [GroupDefinition]
groupBy
      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]
metrics
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextPageToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SortDefinition
sortBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DateInterval
timePeriod

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

instance Data.ToJSON GetReservationCoverage where
  toJSON :: GetReservationCoverage -> Value
toJSON GetReservationCoverage' {Maybe Natural
Maybe [Text]
Maybe [GroupDefinition]
Maybe Text
Maybe Granularity
Maybe SortDefinition
Maybe Expression
DateInterval
timePeriod :: DateInterval
sortBy :: Maybe SortDefinition
nextPageToken :: Maybe Text
metrics :: Maybe [Text]
maxResults :: Maybe Natural
groupBy :: Maybe [GroupDefinition]
granularity :: Maybe Granularity
filter' :: Maybe Expression
$sel:timePeriod:GetReservationCoverage' :: GetReservationCoverage -> DateInterval
$sel:sortBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe SortDefinition
$sel:nextPageToken:GetReservationCoverage' :: GetReservationCoverage -> Maybe Text
$sel:metrics:GetReservationCoverage' :: GetReservationCoverage -> Maybe [Text]
$sel:maxResults:GetReservationCoverage' :: GetReservationCoverage -> Maybe Natural
$sel:groupBy:GetReservationCoverage' :: GetReservationCoverage -> Maybe [GroupDefinition]
$sel:granularity:GetReservationCoverage' :: GetReservationCoverage -> Maybe Granularity
$sel:filter':GetReservationCoverage' :: GetReservationCoverage -> Maybe Expression
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Expression
filter',
            (Key
"Granularity" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Granularity
granularity,
            (Key
"GroupBy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [GroupDefinition]
groupBy,
            (Key
"MaxResults" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxResults,
            (Key
"Metrics" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Text]
metrics,
            (Key
"NextPageToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextPageToken,
            (Key
"SortBy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe SortDefinition
sortBy,
            forall a. a -> Maybe a
Prelude.Just (Key
"TimePeriod" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= DateInterval
timePeriod)
          ]
      )

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

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

-- | /See:/ 'newGetReservationCoverageResponse' smart constructor.
data GetReservationCoverageResponse = GetReservationCoverageResponse'
  { -- | The token for the next set of retrievable results. Amazon Web Services
    -- provides the token when the response from a previous call has more
    -- results than the maximum page size.
    GetReservationCoverageResponse -> Maybe Text
nextPageToken :: Prelude.Maybe Prelude.Text,
    -- | The total amount of instance usage that a reservation covered.
    GetReservationCoverageResponse -> Maybe Coverage
total :: Prelude.Maybe Coverage,
    -- | The response's http status code.
    GetReservationCoverageResponse -> Int
httpStatus :: Prelude.Int,
    -- | The amount of time that your reservations covered.
    GetReservationCoverageResponse -> [CoverageByTime]
coveragesByTime :: [CoverageByTime]
  }
  deriving (GetReservationCoverageResponse
-> GetReservationCoverageResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetReservationCoverageResponse
-> GetReservationCoverageResponse -> Bool
$c/= :: GetReservationCoverageResponse
-> GetReservationCoverageResponse -> Bool
== :: GetReservationCoverageResponse
-> GetReservationCoverageResponse -> Bool
$c== :: GetReservationCoverageResponse
-> GetReservationCoverageResponse -> Bool
Prelude.Eq, ReadPrec [GetReservationCoverageResponse]
ReadPrec GetReservationCoverageResponse
Int -> ReadS GetReservationCoverageResponse
ReadS [GetReservationCoverageResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetReservationCoverageResponse]
$creadListPrec :: ReadPrec [GetReservationCoverageResponse]
readPrec :: ReadPrec GetReservationCoverageResponse
$creadPrec :: ReadPrec GetReservationCoverageResponse
readList :: ReadS [GetReservationCoverageResponse]
$creadList :: ReadS [GetReservationCoverageResponse]
readsPrec :: Int -> ReadS GetReservationCoverageResponse
$creadsPrec :: Int -> ReadS GetReservationCoverageResponse
Prelude.Read, Int -> GetReservationCoverageResponse -> ShowS
[GetReservationCoverageResponse] -> ShowS
GetReservationCoverageResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetReservationCoverageResponse] -> ShowS
$cshowList :: [GetReservationCoverageResponse] -> ShowS
show :: GetReservationCoverageResponse -> String
$cshow :: GetReservationCoverageResponse -> String
showsPrec :: Int -> GetReservationCoverageResponse -> ShowS
$cshowsPrec :: Int -> GetReservationCoverageResponse -> ShowS
Prelude.Show, forall x.
Rep GetReservationCoverageResponse x
-> GetReservationCoverageResponse
forall x.
GetReservationCoverageResponse
-> Rep GetReservationCoverageResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetReservationCoverageResponse x
-> GetReservationCoverageResponse
$cfrom :: forall x.
GetReservationCoverageResponse
-> Rep GetReservationCoverageResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetReservationCoverageResponse' 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:
--
-- 'nextPageToken', 'getReservationCoverageResponse_nextPageToken' - The token for the next set of retrievable results. Amazon Web Services
-- provides the token when the response from a previous call has more
-- results than the maximum page size.
--
-- 'total', 'getReservationCoverageResponse_total' - The total amount of instance usage that a reservation covered.
--
-- 'httpStatus', 'getReservationCoverageResponse_httpStatus' - The response's http status code.
--
-- 'coveragesByTime', 'getReservationCoverageResponse_coveragesByTime' - The amount of time that your reservations covered.
newGetReservationCoverageResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetReservationCoverageResponse
newGetReservationCoverageResponse :: Int -> GetReservationCoverageResponse
newGetReservationCoverageResponse Int
pHttpStatus_ =
  GetReservationCoverageResponse'
    { $sel:nextPageToken:GetReservationCoverageResponse' :: Maybe Text
nextPageToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:total:GetReservationCoverageResponse' :: Maybe Coverage
total = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetReservationCoverageResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:coveragesByTime:GetReservationCoverageResponse' :: [CoverageByTime]
coveragesByTime = forall a. Monoid a => a
Prelude.mempty
    }

-- | The token for the next set of retrievable results. Amazon Web Services
-- provides the token when the response from a previous call has more
-- results than the maximum page size.
getReservationCoverageResponse_nextPageToken :: Lens.Lens' GetReservationCoverageResponse (Prelude.Maybe Prelude.Text)
getReservationCoverageResponse_nextPageToken :: Lens' GetReservationCoverageResponse (Maybe Text)
getReservationCoverageResponse_nextPageToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverageResponse' {Maybe Text
nextPageToken :: Maybe Text
$sel:nextPageToken:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> Maybe Text
nextPageToken} -> Maybe Text
nextPageToken) (\s :: GetReservationCoverageResponse
s@GetReservationCoverageResponse' {} Maybe Text
a -> GetReservationCoverageResponse
s {$sel:nextPageToken:GetReservationCoverageResponse' :: Maybe Text
nextPageToken = Maybe Text
a} :: GetReservationCoverageResponse)

-- | The total amount of instance usage that a reservation covered.
getReservationCoverageResponse_total :: Lens.Lens' GetReservationCoverageResponse (Prelude.Maybe Coverage)
getReservationCoverageResponse_total :: Lens' GetReservationCoverageResponse (Maybe Coverage)
getReservationCoverageResponse_total = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverageResponse' {Maybe Coverage
total :: Maybe Coverage
$sel:total:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> Maybe Coverage
total} -> Maybe Coverage
total) (\s :: GetReservationCoverageResponse
s@GetReservationCoverageResponse' {} Maybe Coverage
a -> GetReservationCoverageResponse
s {$sel:total:GetReservationCoverageResponse' :: Maybe Coverage
total = Maybe Coverage
a} :: GetReservationCoverageResponse)

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

-- | The amount of time that your reservations covered.
getReservationCoverageResponse_coveragesByTime :: Lens.Lens' GetReservationCoverageResponse [CoverageByTime]
getReservationCoverageResponse_coveragesByTime :: Lens' GetReservationCoverageResponse [CoverageByTime]
getReservationCoverageResponse_coveragesByTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetReservationCoverageResponse' {[CoverageByTime]
coveragesByTime :: [CoverageByTime]
$sel:coveragesByTime:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> [CoverageByTime]
coveragesByTime} -> [CoverageByTime]
coveragesByTime) (\s :: GetReservationCoverageResponse
s@GetReservationCoverageResponse' {} [CoverageByTime]
a -> GetReservationCoverageResponse
s {$sel:coveragesByTime:GetReservationCoverageResponse' :: [CoverageByTime]
coveragesByTime = [CoverageByTime]
a} :: GetReservationCoverageResponse) 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

instance
  Prelude.NFData
    GetReservationCoverageResponse
  where
  rnf :: GetReservationCoverageResponse -> ()
rnf GetReservationCoverageResponse' {Int
[CoverageByTime]
Maybe Text
Maybe Coverage
coveragesByTime :: [CoverageByTime]
httpStatus :: Int
total :: Maybe Coverage
nextPageToken :: Maybe Text
$sel:coveragesByTime:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> [CoverageByTime]
$sel:httpStatus:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> Int
$sel:total:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> Maybe Coverage
$sel:nextPageToken:GetReservationCoverageResponse' :: GetReservationCoverageResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextPageToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Coverage
total
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [CoverageByTime]
coveragesByTime