class Aws::ResourceGroupsTaggingAPI::Types::GetResourcesInput

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

data as a hash:

    {
      pagination_token: "PaginationToken",
      tag_filters: [
        {
          key: "TagKey",
          values: ["TagValue"],
        },
      ],
      resources_per_page: 1,
      tags_per_page: 1,
      resource_type_filters: ["AmazonResourceType"],
      include_compliance_details: false,
      exclude_compliant_resources: false,
      resource_arn_list: ["ResourceARN"],
    }

@!attribute [rw] pagination_token

Specifies a `PaginationToken` response value from a previous request
to indicate that you want the next page of results. Leave this
parameter empty in your initial request.
@return [String]

@!attribute [rw] tag_filters

Specifies a list of TagFilters (keys and values) to restrict the
output to only those resources that have the specified tag and, if
included, the specified value. Each `TagFilter` must contain a key
with values optional. A request can include up to 50 keys, and each
key can include up to 20 values.

Note the following when deciding how to use TagFilters:

* If you *don't* specify a `TagFilter`, the response includes all
  resources that are currently tagged or ever had a tag. Resources
  that currently don't have tags are shown with an empty tag set,
  like this: `"Tags": []`.

* If you specify more than one filter in a single request, the
  response returns only those resources that satisfy all filters.

* If you specify a filter that contains more than one value for a
  key, the response returns resources that match any of the
  specified values for that key.

* If you don't specify any values for a key, the response returns
  resources that are tagged with that key and any or no value.

  For example, for the following filters: `filter1=
  \{keyA,\{value1\}\}`, `filter2=\{keyB,\{value2,value3,value4\}\}`,
  `filter3= \{keyC\}`\:

  * `GetResources(\{filter1\})` returns resources tagged with
    `key1=value1`

  * `GetResources(\{filter2\})` returns resources tagged with
    `key2=value2` or `key2=value3` or `key2=value4`

  * `GetResources(\{filter3\})` returns resources tagged with any
    tag with the key `key3`, and with any or no value

  * `GetResources(\{filter1,filter2,filter3\})` returns resources
    tagged with `(key1=value1) and (key2=value2 or key2=value3 or
    key2=value4) and (key3, any or no value)`
@return [Array<Types::TagFilter>]

@!attribute [rw] resources_per_page

Specifies the maximum number of results to be returned in each page.
A query can return fewer than this maximum, even if there are more
results still to return. You should always check the
`PaginationToken` response value to see if there are more results.
You can specify a minimum of 1 and a maximum value of 100.
@return [Integer]

@!attribute [rw] tags_per_page

AWS recommends using `ResourcesPerPage` instead of this parameter.

A limit that restricts the number of tags (key and value pairs)
returned by `GetResources` in paginated output. A resource with no
tags is counted as having one tag (one key and value pair).

`GetResources` does not split a resource and its associated tags
across pages. If the specified `TagsPerPage` would cause such a
break, a `PaginationToken` is returned in place of the affected
resource and its tags. Use that token in another request to get the
remaining data. For example, if you specify a `TagsPerPage` of `100`
and the account has 22 resources with 10 tags each (meaning that
each resource has 10 key and value pairs), the output will consist
of three pages. The first page displays the first 10 resources, each
with its 10 tags. The second page displays the next 10 resources,
each with its 10 tags. The third page displays the remaining 2
resources, each with its 10 tags.

You can set `TagsPerPage` to a minimum of 100 items up to a maximum
of 500 items.
@return [Integer]

@!attribute [rw] resource_type_filters

Specifies the resource types that you want included in the response.
The format of each resource type is `service[:resourceType]`. For
example, specifying a resource type of `ec2` returns all Amazon EC2
resources (which includes EC2 instances). Specifying a resource type
of `ec2:instance` returns only EC2 instances.

The string for each service name and resource type is the same as
that embedded in a resource's Amazon Resource Name (ARN). Consult
the *AWS General Reference* for the following:

For more information about ARNs, see [Amazon Resource Names (ARNs)
and AWS Service Namespaces][1].

You can specify multiple resource types by using an array. The array
can include up to 100 items. Note that the length constraint
requirement applies to each resource type filter.

[1]: https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html
@return [Array<String>]

@!attribute [rw] include_compliance_details

Specifies whether to include details regarding the compliance with
the effective tag policy. Set this to `true` to determine whether
resources are compliant with the tag policy and to get details.
@return [Boolean]

@!attribute [rw] exclude_compliant_resources

Specifies whether to exclude resources that are compliant with the
tag policy. Set this to `true` if you are interested in retrieving
information on noncompliant resources only.

You can use this parameter only if the `IncludeComplianceDetails`
parameter is also set to `true`.
@return [Boolean]

@!attribute [rw] resource_arn_list

Specifies a list of ARNs of resources for which you want to retrieve
tag data. You can't specify both this parameter and any of the
pagination parameters (`ResourcesPerPage`, `TagsPerPage`,
`PaginationToken`) in the same request. If you specify both, you get
an `Invalid Parameter` exception.

If a resource specified by this parameter doesn't exist, it
doesn't generate an error; it simply isn't included in the
response.

An ARN (Amazon Resource Name) uniquely identifies a resource. For
more information, see [Amazon Resource Names (ARNs) and AWS Service
Namespaces][1] in the *AWS General Reference*.

[1]: http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html
@return [Array<String>]

@see docs.aws.amazon.com/goto/WebAPI/resourcegroupstaggingapi-2017-01-26/GetResourcesInput AWS API Documentation

Constants

SENSITIVE