class Aws::CostExplorer::Types::GetCostCategoriesRequest

@note When making an API call, you may pass GetCostCategoriesRequest

data as a hash:

    {
      search_string: "SearchString",
      time_period: { # required
        start: "YearMonthDay", # required
        end: "YearMonthDay", # required
      },
      cost_category_name: "CostCategoryName",
      filter: {
        or: [
          {
            # recursive Expression
          },
        ],
        and: [
          {
            # recursive Expression
          },
        ],
        not: {
          # recursive Expression
        },
        dimensions: {
          key: "AZ", # accepts AZ, INSTANCE_TYPE, LINKED_ACCOUNT, LINKED_ACCOUNT_NAME, OPERATION, PURCHASE_TYPE, REGION, SERVICE, SERVICE_CODE, USAGE_TYPE, USAGE_TYPE_GROUP, RECORD_TYPE, OPERATING_SYSTEM, TENANCY, SCOPE, PLATFORM, SUBSCRIPTION_ID, LEGAL_ENTITY_NAME, DEPLOYMENT_OPTION, DATABASE_ENGINE, CACHE_ENGINE, INSTANCE_TYPE_FAMILY, BILLING_ENTITY, RESERVATION_ID, RESOURCE_ID, RIGHTSIZING_TYPE, SAVINGS_PLANS_TYPE, SAVINGS_PLAN_ARN, PAYMENT_OPTION, AGREEMENT_END_DATE_TIME_AFTER, AGREEMENT_END_DATE_TIME_BEFORE
          values: ["Value"],
          match_options: ["EQUALS"], # accepts EQUALS, ABSENT, STARTS_WITH, ENDS_WITH, CONTAINS, CASE_SENSITIVE, CASE_INSENSITIVE
        },
        tags: {
          key: "TagKey",
          values: ["Value"],
          match_options: ["EQUALS"], # accepts EQUALS, ABSENT, STARTS_WITH, ENDS_WITH, CONTAINS, CASE_SENSITIVE, CASE_INSENSITIVE
        },
        cost_categories: {
          key: "CostCategoryName",
          values: ["Value"],
          match_options: ["EQUALS"], # accepts EQUALS, ABSENT, STARTS_WITH, ENDS_WITH, CONTAINS, CASE_SENSITIVE, CASE_INSENSITIVE
        },
      },
      sort_by: [
        {
          key: "SortDefinitionKey", # required
          sort_order: "ASCENDING", # accepts ASCENDING, DESCENDING
        },
      ],
      max_results: 1,
      next_page_token: "NextPageToken",
    }

@!attribute [rw] search_string

The value that you want to search the filter values for.

If you do not specify a `CostCategoryName`, `SearchString` will be
used to filter Cost Category names that match the `SearchString`
pattern. If you do specifiy a `CostCategoryName`, `SearchString`
will be used to filter Cost Category values that match the
`SearchString` pattern.
@return [String]

@!attribute [rw] time_period

The time period of the request.
@return [Types::DateInterval]

@!attribute [rw] cost_category_name

The unique name of the Cost Category.
@return [String]

@!attribute [rw] filter

Use `Expression` to filter by cost or by usage. There are two
patterns:

* Simple dimension values - You can set the dimension name and
  values for the filters that you plan to use. For example, you can
  filter for `REGION==us-east-1 OR REGION==us-west-1`. For
  `GetRightsizingRecommendation`, the Region is a full name (for
  example, `REGION==US East (N. Virginia)`. The `Expression` example
  is as follows:

  `\{ "Dimensions": \{ "Key": "REGION", "Values": [ "us-east-1",
  “us-west-1” ] \} \}`

  The list of dimension values are OR'd together to retrieve cost
  or usage data. You can create `Expression` and `DimensionValues`
  objects using either `with*` methods or `set*` methods in multiple
  lines.

* Compound dimension values with logical operations - You can use
  multiple `Expression` types and the logical operators `AND/OR/NOT`
  to create a list of one or more `Expression` objects. By doing
  this, you can filter on more advanced options. For example, you
  can filter on `((REGION == us-east-1 OR REGION == us-west-1) OR
  (TAG.Type == Type1)) AND (USAGE_TYPE != DataTransfer)`. The
  `Expression` for that is as follows:

  `\{ "And": [ \{"Or": [ \{"Dimensions": \{ "Key": "REGION",
  "Values": [ "us-east-1", "us-west-1" ] \}\}, \{"Tags": \{ "Key":
  "TagName", "Values": ["Value1"] \} \} ]\}, \{"Not":
  \{"Dimensions": \{ "Key": "USAGE_TYPE", "Values": ["DataTransfer"]
  \}\}\} ] \} `

  <note markdown="1"> Because each `Expression` can have only one operator, the service
  returns an error if more than one is specified. The following
  example shows an `Expression` object that creates an error.

   </note>

  ` \{ "And": [ ... ], "DimensionValues": \{ "Dimension":
  "USAGE_TYPE", "Values": [ "DataTransfer" ] \} \} `

<note markdown="1"> For the `GetRightsizingRecommendation` action, a combination of OR
and NOT isn't supported. OR isn't supported between different
dimensions, or dimensions and tags. NOT operators aren't supported.
Dimensions are also limited to `LINKED_ACCOUNT`, `REGION`, or
`RIGHTSIZING_TYPE`.

 For the `GetReservationPurchaseRecommendation` action, only NOT is
supported. AND and OR aren't supported. Dimensions are limited to
`LINKED_ACCOUNT`.

 </note>
@return [Types::Expression]

@!attribute [rw] sort_by

The value by which you want to sort the data.

The key represents cost and usage metrics. The following values are
supported:

* `BlendedCost`

* `UnblendedCost`

* `AmortizedCost`

* `NetAmortizedCost`

* `NetUnblendedCost`

* `UsageQuantity`

* `NormalizedUsageAmount`

Supported values for `SortOrder` are `ASCENDING` or `DESCENDING`.

When using `SortBy`, `NextPageToken` and `SearchString` are not
supported.
@return [Array<Types::SortDefinition>]

@!attribute [rw] max_results

This field is only used when `SortBy` is provided in the request.

The maximum number of objects that to be returned for this request.
If `MaxResults` is not specified with `SortBy`, the request will
return 1000 results as the default value for this parameter.

For `GetCostCategories`, MaxResults has an upper limit of 1000.
@return [Integer]

@!attribute [rw] next_page_token

If the number of objects that are still available for retrieval
exceeds the limit, Amazon Web Services returns a NextPageToken value
in the response. To retrieve the next batch of objects, provide the
NextPageToken from the prior call in your next request.
@return [String]

@see docs.aws.amazon.com/goto/WebAPI/ce-2017-10-25/GetCostCategoriesRequest AWS API Documentation

Constants

SENSITIVE