@aws-sdk/client-resource-groups 3.50.0 → 3.53.0

package/dist-types/ts3.4/commands/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./CreateGroupCommand";
+export * from "./DeleteGroupCommand";
+export * from "./GetGroupCommand";
+export * from "./GetGroupConfigurationCommand";
+export * from "./GetGroupQueryCommand";
+export * from "./GetTagsCommand";
+export * from "./GroupResourcesCommand";
+export * from "./ListGroupResourcesCommand";
+export * from "./ListGroupsCommand";
+export * from "./PutGroupConfigurationCommand";
+export * from "./SearchResourcesCommand";
+export * from "./TagCommand";
+export * from "./UngroupResourcesCommand";
+export * from "./UntagCommand";
+export * from "./UpdateGroupCommand";
+export * from "./UpdateGroupQueryCommand";

package/dist-types/ts3.4/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./ResourceGroups";
+export * from "./ResourceGroupsClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { ResourceGroupsServiceException } from "./models/ResourceGroupsServiceException";

package/dist-types/ts3.4/models/ResourceGroupsServiceException.d.ts

@@ -0,0 +1,6 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+
+export declare class ResourceGroupsServiceException extends __ServiceException {
+    
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/ts3.4/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,596 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ResourceGroupsServiceException as __BaseException } from "./ResourceGroupsServiceException";
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+
+export interface GroupConfigurationParameter {
+    
+    Name: string | undefined;
+    
+    Values?: string[];
+}
+export declare namespace GroupConfigurationParameter {
+    
+    const filterSensitiveLog: (obj: GroupConfigurationParameter) => any;
+}
+
+export interface GroupConfigurationItem {
+    
+    Type: string | undefined;
+    
+    Parameters?: GroupConfigurationParameter[];
+}
+export declare namespace GroupConfigurationItem {
+    
+    const filterSensitiveLog: (obj: GroupConfigurationItem) => any;
+}
+export declare enum QueryType {
+    CLOUDFORMATION_STACK_1_0 = "CLOUDFORMATION_STACK_1_0",
+    TAG_FILTERS_1_0 = "TAG_FILTERS_1_0"
+}
+
+export interface ResourceQuery {
+    
+    Type: QueryType | string | undefined;
+    
+    Query: string | undefined;
+}
+export declare namespace ResourceQuery {
+    
+    const filterSensitiveLog: (obj: ResourceQuery) => any;
+}
+export interface CreateGroupInput {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    ResourceQuery?: ResourceQuery;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    Configuration?: GroupConfigurationItem[];
+}
+export declare namespace CreateGroupInput {
+    
+    const filterSensitiveLog: (obj: CreateGroupInput) => any;
+}
+
+export interface Group {
+    
+    GroupArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace Group {
+    
+    const filterSensitiveLog: (obj: Group) => any;
+}
+export declare enum GroupConfigurationStatus {
+    UPDATE_COMPLETE = "UPDATE_COMPLETE",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATING = "UPDATING"
+}
+
+export interface GroupConfiguration {
+    
+    Configuration?: GroupConfigurationItem[];
+    
+    ProposedConfiguration?: GroupConfigurationItem[];
+    
+    Status?: GroupConfigurationStatus | string;
+    
+    FailureReason?: string;
+}
+export declare namespace GroupConfiguration {
+    
+    const filterSensitiveLog: (obj: GroupConfiguration) => any;
+}
+export interface CreateGroupOutput {
+    
+    Group?: Group;
+    
+    ResourceQuery?: ResourceQuery;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    GroupConfiguration?: GroupConfiguration;
+}
+export declare namespace CreateGroupOutput {
+    
+    const filterSensitiveLog: (obj: CreateGroupOutput) => any;
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class InternalServerErrorException extends __BaseException {
+    readonly name: "InternalServerErrorException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerErrorException, __BaseException>);
+}
+
+export declare class MethodNotAllowedException extends __BaseException {
+    readonly name: "MethodNotAllowedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MethodNotAllowedException, __BaseException>);
+}
+
+export declare class TooManyRequestsException extends __BaseException {
+    readonly name: "TooManyRequestsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequestsException, __BaseException>);
+}
+export interface DeleteGroupInput {
+    
+    GroupName?: string;
+    
+    Group?: string;
+}
+export declare namespace DeleteGroupInput {
+    
+    const filterSensitiveLog: (obj: DeleteGroupInput) => any;
+}
+export interface DeleteGroupOutput {
+    
+    Group?: Group;
+}
+export declare namespace DeleteGroupOutput {
+    
+    const filterSensitiveLog: (obj: DeleteGroupOutput) => any;
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+export interface GetGroupInput {
+    
+    GroupName?: string;
+    
+    Group?: string;
+}
+export declare namespace GetGroupInput {
+    
+    const filterSensitiveLog: (obj: GetGroupInput) => any;
+}
+export interface GetGroupOutput {
+    
+    Group?: Group;
+}
+export declare namespace GetGroupOutput {
+    
+    const filterSensitiveLog: (obj: GetGroupOutput) => any;
+}
+export interface GetGroupConfigurationInput {
+    
+    Group?: string;
+}
+export declare namespace GetGroupConfigurationInput {
+    
+    const filterSensitiveLog: (obj: GetGroupConfigurationInput) => any;
+}
+export interface GetGroupConfigurationOutput {
+    
+    GroupConfiguration?: GroupConfiguration;
+}
+export declare namespace GetGroupConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: GetGroupConfigurationOutput) => any;
+}
+export interface GetGroupQueryInput {
+    
+    GroupName?: string;
+    
+    Group?: string;
+}
+export declare namespace GetGroupQueryInput {
+    
+    const filterSensitiveLog: (obj: GetGroupQueryInput) => any;
+}
+
+export interface GroupQuery {
+    
+    GroupName: string | undefined;
+    
+    ResourceQuery: ResourceQuery | undefined;
+}
+export declare namespace GroupQuery {
+    
+    const filterSensitiveLog: (obj: GroupQuery) => any;
+}
+export interface GetGroupQueryOutput {
+    
+    GroupQuery?: GroupQuery;
+}
+export declare namespace GetGroupQueryOutput {
+    
+    const filterSensitiveLog: (obj: GetGroupQueryOutput) => any;
+}
+export interface GetTagsInput {
+    
+    Arn: string | undefined;
+}
+export declare namespace GetTagsInput {
+    
+    const filterSensitiveLog: (obj: GetTagsInput) => any;
+}
+export interface GetTagsOutput {
+    
+    Arn?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetTagsOutput {
+    
+    const filterSensitiveLog: (obj: GetTagsOutput) => any;
+}
+export interface GroupResourcesInput {
+    
+    Group: string | undefined;
+    
+    ResourceArns: string[] | undefined;
+}
+export declare namespace GroupResourcesInput {
+    
+    const filterSensitiveLog: (obj: GroupResourcesInput) => any;
+}
+
+export interface FailedResource {
+    
+    ResourceArn?: string;
+    
+    ErrorMessage?: string;
+    
+    ErrorCode?: string;
+}
+export declare namespace FailedResource {
+    
+    const filterSensitiveLog: (obj: FailedResource) => any;
+}
+
+export interface PendingResource {
+    
+    ResourceArn?: string;
+}
+export declare namespace PendingResource {
+    
+    const filterSensitiveLog: (obj: PendingResource) => any;
+}
+export interface GroupResourcesOutput {
+    
+    Succeeded?: string[];
+    
+    Failed?: FailedResource[];
+    
+    Pending?: PendingResource[];
+}
+export declare namespace GroupResourcesOutput {
+    
+    const filterSensitiveLog: (obj: GroupResourcesOutput) => any;
+}
+export declare enum ResourceFilterName {
+    ResourceType = "resource-type"
+}
+
+export interface ResourceFilter {
+    
+    Name: ResourceFilterName | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace ResourceFilter {
+    
+    const filterSensitiveLog: (obj: ResourceFilter) => any;
+}
+export interface ListGroupResourcesInput {
+    
+    GroupName?: string;
+    
+    Group?: string;
+    
+    Filters?: ResourceFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListGroupResourcesInput {
+    
+    const filterSensitiveLog: (obj: ListGroupResourcesInput) => any;
+}
+export declare enum QueryErrorCode {
+    CLOUDFORMATION_STACK_INACTIVE = "CLOUDFORMATION_STACK_INACTIVE",
+    CLOUDFORMATION_STACK_NOT_EXISTING = "CLOUDFORMATION_STACK_NOT_EXISTING"
+}
+
+export interface QueryError {
+    
+    ErrorCode?: QueryErrorCode | string;
+    
+    Message?: string;
+}
+export declare namespace QueryError {
+    
+    const filterSensitiveLog: (obj: QueryError) => any;
+}
+
+export interface ResourceIdentifier {
+    
+    ResourceArn?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace ResourceIdentifier {
+    
+    const filterSensitiveLog: (obj: ResourceIdentifier) => any;
+}
+export declare enum ResourceStatusValue {
+    Pending = "PENDING"
+}
+
+export interface ResourceStatus {
+    
+    Name?: ResourceStatusValue | string;
+}
+export declare namespace ResourceStatus {
+    
+    const filterSensitiveLog: (obj: ResourceStatus) => any;
+}
+
+export interface ListGroupResourcesItem {
+    
+    Identifier?: ResourceIdentifier;
+    
+    Status?: ResourceStatus;
+}
+export declare namespace ListGroupResourcesItem {
+    
+    const filterSensitiveLog: (obj: ListGroupResourcesItem) => any;
+}
+export interface ListGroupResourcesOutput {
+    
+    Resources?: ListGroupResourcesItem[];
+    
+    ResourceIdentifiers?: ResourceIdentifier[];
+    
+    NextToken?: string;
+    
+    QueryErrors?: QueryError[];
+}
+export declare namespace ListGroupResourcesOutput {
+    
+    const filterSensitiveLog: (obj: ListGroupResourcesOutput) => any;
+}
+
+export declare class UnauthorizedException extends __BaseException {
+    readonly name: "UnauthorizedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnauthorizedException, __BaseException>);
+}
+export declare enum GroupFilterName {
+    ConfigurationType = "configuration-type",
+    ResourceType = "resource-type"
+}
+
+export interface GroupFilter {
+    
+    Name: GroupFilterName | string | undefined;
+    
+    Values: string[] | undefined;
+}
+export declare namespace GroupFilter {
+    
+    const filterSensitiveLog: (obj: GroupFilter) => any;
+}
+export interface ListGroupsInput {
+    
+    Filters?: GroupFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListGroupsInput {
+    
+    const filterSensitiveLog: (obj: ListGroupsInput) => any;
+}
+
+export interface GroupIdentifier {
+    
+    GroupName?: string;
+    
+    GroupArn?: string;
+}
+export declare namespace GroupIdentifier {
+    
+    const filterSensitiveLog: (obj: GroupIdentifier) => any;
+}
+export interface ListGroupsOutput {
+    
+    GroupIdentifiers?: GroupIdentifier[];
+    
+    Groups?: Group[];
+    
+    NextToken?: string;
+}
+export declare namespace ListGroupsOutput {
+    
+    const filterSensitiveLog: (obj: ListGroupsOutput) => any;
+}
+export interface PutGroupConfigurationInput {
+    
+    Group?: string;
+    
+    Configuration?: GroupConfigurationItem[];
+}
+export declare namespace PutGroupConfigurationInput {
+    
+    const filterSensitiveLog: (obj: PutGroupConfigurationInput) => any;
+}
+export interface PutGroupConfigurationOutput {
+}
+export declare namespace PutGroupConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: PutGroupConfigurationOutput) => any;
+}
+export interface SearchResourcesInput {
+    
+    ResourceQuery: ResourceQuery | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace SearchResourcesInput {
+    
+    const filterSensitiveLog: (obj: SearchResourcesInput) => any;
+}
+export interface SearchResourcesOutput {
+    
+    ResourceIdentifiers?: ResourceIdentifier[];
+    
+    NextToken?: string;
+    
+    QueryErrors?: QueryError[];
+}
+export declare namespace SearchResourcesOutput {
+    
+    const filterSensitiveLog: (obj: SearchResourcesOutput) => any;
+}
+export interface TagInput {
+    
+    Arn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagInput {
+    
+    const filterSensitiveLog: (obj: TagInput) => any;
+}
+export interface TagOutput {
+    
+    Arn?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace TagOutput {
+    
+    const filterSensitiveLog: (obj: TagOutput) => any;
+}
+export interface UngroupResourcesInput {
+    
+    Group: string | undefined;
+    
+    ResourceArns: string[] | undefined;
+}
+export declare namespace UngroupResourcesInput {
+    
+    const filterSensitiveLog: (obj: UngroupResourcesInput) => any;
+}
+export interface UngroupResourcesOutput {
+    
+    Succeeded?: string[];
+    
+    Failed?: FailedResource[];
+    
+    Pending?: PendingResource[];
+}
+export declare namespace UngroupResourcesOutput {
+    
+    const filterSensitiveLog: (obj: UngroupResourcesOutput) => any;
+}
+export interface UntagInput {
+    
+    Arn: string | undefined;
+    
+    Keys: string[] | undefined;
+}
+export declare namespace UntagInput {
+    
+    const filterSensitiveLog: (obj: UntagInput) => any;
+}
+export interface UntagOutput {
+    
+    Arn?: string;
+    
+    Keys?: string[];
+}
+export declare namespace UntagOutput {
+    
+    const filterSensitiveLog: (obj: UntagOutput) => any;
+}
+export interface UpdateGroupInput {
+    
+    GroupName?: string;
+    
+    Group?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateGroupInput {
+    
+    const filterSensitiveLog: (obj: UpdateGroupInput) => any;
+}
+export interface UpdateGroupOutput {
+    
+    Group?: Group;
+}
+export declare namespace UpdateGroupOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGroupOutput) => any;
+}
+export interface UpdateGroupQueryInput {
+    
+    GroupName?: string;
+    
+    Group?: string;
+    
+    ResourceQuery: ResourceQuery | undefined;
+}
+export declare namespace UpdateGroupQueryInput {
+    
+    const filterSensitiveLog: (obj: UpdateGroupQueryInput) => any;
+}
+export interface UpdateGroupQueryOutput {
+    
+    GroupQuery?: GroupQuery;
+}
+export declare namespace UpdateGroupQueryOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGroupQueryOutput) => any;
+}

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@aws-sdk/types";
+import { ResourceGroups } from "../ResourceGroups";
+import { ResourceGroupsClient } from "../ResourceGroupsClient";
+export interface ResourceGroupsPaginationConfiguration extends PaginationConfiguration {
+    client: ResourceGroups | ResourceGroupsClient;
+}

package/dist-types/ts3.4/pagination/ListGroupResourcesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListGroupResourcesCommandInput, ListGroupResourcesCommandOutput } from "../commands/ListGroupResourcesCommand";
+import { ResourceGroupsPaginationConfiguration } from "./Interfaces";
+export declare function paginateListGroupResources(config: ResourceGroupsPaginationConfiguration, input: ListGroupResourcesCommandInput, ...additionalArguments: any): Paginator<ListGroupResourcesCommandOutput>;

package/dist-types/ts3.4/pagination/ListGroupsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListGroupsCommandInput, ListGroupsCommandOutput } from "../commands/ListGroupsCommand";
+import { ResourceGroupsPaginationConfiguration } from "./Interfaces";
+export declare function paginateListGroups(config: ResourceGroupsPaginationConfiguration, input: ListGroupsCommandInput, ...additionalArguments: any): Paginator<ListGroupsCommandOutput>;

package/dist-types/ts3.4/pagination/SearchResourcesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { SearchResourcesCommandInput, SearchResourcesCommandOutput } from "../commands/SearchResourcesCommand";
+import { ResourceGroupsPaginationConfiguration } from "./Interfaces";
+export declare function paginateSearchResources(config: ResourceGroupsPaginationConfiguration, input: SearchResourcesCommandInput, ...additionalArguments: any): Paginator<SearchResourcesCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Interfaces";
+export * from "./ListGroupResourcesPaginator";
+export * from "./ListGroupsPaginator";
+export * from "./SearchResourcesPaginator";