@aws-sdk/client-config-service 3.31.0 → 3.35.0

package/dist/types/commands/SelectResourceConfigCommand.d.ts

@@ -1,39 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { SelectResourceConfigRequest, SelectResourceConfigResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SelectResourceConfigCommandInput extends SelectResourceConfigRequest {
-}
-export interface SelectResourceConfigCommandOutput extends SelectResourceConfigResponse, __MetadataBearer {
-}
-/**
- * <p>Accepts a structured query language (SQL) <code>SELECT</code> command, performs the corresponding search, and returns resource configurations matching the properties.</p>
- * 		       <p>For more information about query components, see the
- * 			<a href="https://docs.aws.amazon.com/config/latest/developerguide/query-components.html">
- *                <b>Query Components</b>
- *             </a> section in the Config Developer Guide.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, SelectResourceConfigCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, SelectResourceConfigCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new SelectResourceConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SelectResourceConfigCommandInput} for command's `input` shape.
- * @see {@link SelectResourceConfigCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SelectResourceConfigCommand extends $Command<SelectResourceConfigCommandInput, SelectResourceConfigCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: SelectResourceConfigCommandInput;
-    constructor(input: SelectResourceConfigCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SelectResourceConfigCommandInput, SelectResourceConfigCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/StartConfigRulesEvaluationCommand.d.ts

@@ -1,82 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { StartConfigRulesEvaluationRequest, StartConfigRulesEvaluationResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartConfigRulesEvaluationCommandInput extends StartConfigRulesEvaluationRequest {
-}
-export interface StartConfigRulesEvaluationCommandOutput extends StartConfigRulesEvaluationResponse, __MetadataBearer {
-}
-/**
- * <p>Runs an on-demand evaluation for the specified Config rules
- * 			against the last known configuration state of the resources. Use
- * 				<code>StartConfigRulesEvaluation</code> when you want to test
- * 			that a rule you updated is working as expected.
- * 				<code>StartConfigRulesEvaluation</code> does not re-record the
- * 			latest configuration state for your resources. It re-runs an
- * 			evaluation against the last known state of your resources. </p>
- * 		       <p>You can specify up to 25 Config rules per request. </p>
- *
- *
- * 		       <p>An existing <code>StartConfigRulesEvaluation</code> call for
- * 			the specified rules must complete before you can call the API again.
- * 			If you chose to have Config stream to an Amazon SNS topic, you
- * 			will receive a <code>ConfigRuleEvaluationStarted</code> notification
- * 			when the evaluation starts.</p>
- * 		       <note>
- * 			         <p>You don't need to call the
- * 					<code>StartConfigRulesEvaluation</code> API to run an
- * 				evaluation for a new rule. When you create a rule, Config
- * 				evaluates your resources against the rule automatically.
- * 			</p>
- * 		       </note>
- * 		       <p>The <code>StartConfigRulesEvaluation</code> API is useful if
- * 			you want to run on-demand evaluations, such as the following
- * 			example:</p>
- * 		       <ol>
- *             <li>
- * 				           <p>You have a custom rule that evaluates your IAM
- * 					resources every 24 hours.</p>
- * 			         </li>
- *             <li>
- * 				           <p>You update your Lambda function to add additional
- * 					conditions to your rule.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Instead of waiting for the next periodic evaluation,
- * 					you call the <code>StartConfigRulesEvaluation</code>
- * 					API.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Config invokes your Lambda function and evaluates
- * 					your IAM resources.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Your custom rule will still run periodic evaluations
- * 					every 24 hours.</p>
- * 			         </li>
- *          </ol>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, StartConfigRulesEvaluationCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, StartConfigRulesEvaluationCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new StartConfigRulesEvaluationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartConfigRulesEvaluationCommandInput} for command's `input` shape.
- * @see {@link StartConfigRulesEvaluationCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartConfigRulesEvaluationCommand extends $Command<StartConfigRulesEvaluationCommandInput, StartConfigRulesEvaluationCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: StartConfigRulesEvaluationCommandInput;
-    constructor(input: StartConfigRulesEvaluationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartConfigRulesEvaluationCommandInput, StartConfigRulesEvaluationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/StartConfigurationRecorderCommand.d.ts

@@ -1,38 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { StartConfigurationRecorderRequest } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartConfigurationRecorderCommandInput extends StartConfigurationRecorderRequest {
-}
-export interface StartConfigurationRecorderCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Starts recording configurations of the Amazon Web Services resources you have
- * 			selected to record in your Amazon Web Services account.</p>
- * 		       <p>You must have created at least one delivery channel to
- * 			successfully start the configuration recorder.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, StartConfigurationRecorderCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, StartConfigurationRecorderCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new StartConfigurationRecorderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartConfigurationRecorderCommandInput} for command's `input` shape.
- * @see {@link StartConfigurationRecorderCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartConfigurationRecorderCommand extends $Command<StartConfigurationRecorderCommandInput, StartConfigurationRecorderCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: StartConfigurationRecorderCommandInput;
-    constructor(input: StartConfigurationRecorderCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartConfigurationRecorderCommandInput, StartConfigurationRecorderCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/StartRemediationExecutionCommand.d.ts

@@ -1,36 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { StartRemediationExecutionRequest, StartRemediationExecutionResponse } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartRemediationExecutionCommandInput extends StartRemediationExecutionRequest {
-}
-export interface StartRemediationExecutionCommandOutput extends StartRemediationExecutionResponse, __MetadataBearer {
-}
-/**
- * <p>Runs an on-demand remediation for the specified Config rules against the last known remediation configuration. It runs an execution against the current state of your resources. Remediation execution is asynchronous.</p>
- * 			      <p>You can specify up to 100 resource keys per request. An existing StartRemediationExecution call for the specified resource keys must complete before you can call the API again.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, StartRemediationExecutionCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, StartRemediationExecutionCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new StartRemediationExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartRemediationExecutionCommandInput} for command's `input` shape.
- * @see {@link StartRemediationExecutionCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartRemediationExecutionCommand extends $Command<StartRemediationExecutionCommandInput, StartRemediationExecutionCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: StartRemediationExecutionCommandInput;
-    constructor(input: StartRemediationExecutionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartRemediationExecutionCommandInput, StartRemediationExecutionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/StopConfigurationRecorderCommand.d.ts

@@ -1,35 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { StopConfigurationRecorderRequest } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopConfigurationRecorderCommandInput extends StopConfigurationRecorderRequest {
-}
-export interface StopConfigurationRecorderCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Stops recording configurations of the Amazon Web Services resources you have selected to record in your Amazon Web Services account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, StopConfigurationRecorderCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, StopConfigurationRecorderCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new StopConfigurationRecorderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopConfigurationRecorderCommandInput} for command's `input` shape.
- * @see {@link StopConfigurationRecorderCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopConfigurationRecorderCommand extends $Command<StopConfigurationRecorderCommandInput, StopConfigurationRecorderCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: StopConfigurationRecorderCommandInput;
-    constructor(input: StopConfigurationRecorderCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopConfigurationRecorderCommandInput, StopConfigurationRecorderCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/TagResourceCommand.d.ts

@@ -1,36 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { TagResourceRequest } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TagResourceCommandInput extends TagResourceRequest {
-}
-export interface TagResourceCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Associates the specified tags to a resource with the specified resourceArn. If existing tags on a resource are not specified in the request parameters, they are not changed.
- * 			When a resource is deleted, the tags associated with that resource are deleted as well.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, TagResourceCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, TagResourceCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/UntagResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
-import { UntagResourceRequest } from "../models/models_1";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UntagResourceCommandInput extends UntagResourceRequest {
-}
-export interface UntagResourceCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes specified tags from a resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ConfigServiceClient, UntagResourceCommand } from "@aws-sdk/client-config-service"; // ES Modules import
- * // const { ConfigServiceClient, UntagResourceCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
- * const client = new ConfigServiceClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, ConfigServiceClientResolvedConfig> {
-    readonly input: UntagResourceCommandInput;
-    constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/models/models_1.d.ts

@@ -1,362 +0,0 @@
-import { FieldInfo, ResourceKey, RetentionConfiguration, StoredQuery, Tag } from "./models_0";
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
-export interface PutResourceConfigRequest {
-    /**
-     * <p>The type of the resource. The custom resource type must be registered with CloudFormation. </p>
-     * 		       <note>
-     *             <p>You cannot use the organization names “amzn”, “amazon”, “alexa”, “custom” with custom resource types. It is the first part of the ResourceType up to the first ::.</p>
-     *          </note>
-     */
-    ResourceType: string | undefined;
-    /**
-     * <p>Version of the schema registered for the ResourceType in CloudFormation.</p>
-     */
-    SchemaVersionId: string | undefined;
-    /**
-     * <p>Unique identifier of the resource.</p>
-     */
-    ResourceId: string | undefined;
-    /**
-     * <p>Name of the resource.</p>
-     */
-    ResourceName?: string;
-    /**
-     * <p>The configuration object of the resource in valid JSON format. It must match the schema registered with CloudFormation.</p>
-     * 		       <note>
-     *             <p>The configuration JSON must not exceed 64 KB.</p>
-     *          </note>
-     */
-    Configuration: string | undefined;
-    /**
-     * <p>Tags associated with the resource.</p>
-     */
-    Tags?: {
-        [key: string]: string;
-    };
-}
-export declare namespace PutResourceConfigRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: PutResourceConfigRequest) => any;
-}
-export interface PutRetentionConfigurationRequest {
-    /**
-     * <p>Number of days Config stores your historical
-     * 			information.</p>
-     * 		       <note>
-     * 			         <p>Currently, only applicable to the configuration item
-     * 				history.</p>
-     * 		       </note>
-     */
-    RetentionPeriodInDays: number | undefined;
-}
-export declare namespace PutRetentionConfigurationRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: PutRetentionConfigurationRequest) => any;
-}
-export interface PutRetentionConfigurationResponse {
-    /**
-     * <p>Returns a retention configuration object.</p>
-     */
-    RetentionConfiguration?: RetentionConfiguration;
-}
-export declare namespace PutRetentionConfigurationResponse {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: PutRetentionConfigurationResponse) => any;
-}
-export interface PutStoredQueryRequest {
-    /**
-     * <p>A list of <code>StoredQuery</code> objects.
-     * 			The mandatory fields are <code>QueryName</code> and <code>Expression</code>.</p>
-     * 		       <note>
-     *             <p>When you are creating a query, you must provide a query name and an expression.
-     * 			When you are updating a query, you must provide a query name but updating the description is optional.</p>
-     *          </note>
-     */
-    StoredQuery: StoredQuery | undefined;
-    /**
-     * <p>A list of <code>Tags</code> object.</p>
-     */
-    Tags?: Tag[];
-}
-export declare namespace PutStoredQueryRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: PutStoredQueryRequest) => any;
-}
-export interface PutStoredQueryResponse {
-    /**
-     * <p>Amazon Resource Name (ARN) of the query.
-     * 			For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.</p>
-     */
-    QueryArn?: string;
-}
-export declare namespace PutStoredQueryResponse {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: PutStoredQueryResponse) => any;
-}
-/**
- * <p>Two users are trying to modify the same query at the same time. Wait for a moment and try again.</p>
- */
-export interface ResourceConcurrentModificationException extends __SmithyException, $MetadataBearer {
-    name: "ResourceConcurrentModificationException";
-    $fault: "client";
-    message?: string;
-}
-export declare namespace ResourceConcurrentModificationException {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: ResourceConcurrentModificationException) => any;
-}
-/**
- * <p>You have reached the limit of the number of tags you can use. You have more than 50 tags.</p>
- */
-export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
-    name: "TooManyTagsException";
-    $fault: "client";
-    /**
-     * <p>Error executing the command</p>
-     */
-    message?: string;
-}
-export declare namespace TooManyTagsException {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: TooManyTagsException) => any;
-}
-/**
- * <p>Details about the query.</p>
- */
-export interface QueryInfo {
-    /**
-     * <p>Returns a <code>FieldInfo</code> object.</p>
-     */
-    SelectFields?: FieldInfo[];
-}
-export declare namespace QueryInfo {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: QueryInfo) => any;
-}
-export interface SelectAggregateResourceConfigRequest {
-    /**
-     * <p>The SQL query SELECT command. </p>
-     */
-    Expression: string | undefined;
-    /**
-     * <p>The name of the configuration aggregator.</p>
-     */
-    ConfigurationAggregatorName: string | undefined;
-    /**
-     * <p>The maximum number of query results returned on each page. </p>
-     */
-    Limit?: number;
-    /**
-     * <p>The maximum number of query results returned on each page. Config also allows the Limit request parameter.</p>
-     */
-    MaxResults?: number;
-    /**
-     * <p>The nextToken string returned in a previous request that you use to request the next page of results in a paginated response. </p>
-     */
-    NextToken?: string;
-}
-export declare namespace SelectAggregateResourceConfigRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: SelectAggregateResourceConfigRequest) => any;
-}
-export interface SelectAggregateResourceConfigResponse {
-    /**
-     * <p>Returns the results for the SQL query.</p>
-     */
-    Results?: string[];
-    /**
-     * <p>Details about the query.</p>
-     */
-    QueryInfo?: QueryInfo;
-    /**
-     * <p>The nextToken string returned in a previous request that you use to request the next page of results in a paginated response. </p>
-     */
-    NextToken?: string;
-}
-export declare namespace SelectAggregateResourceConfigResponse {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: SelectAggregateResourceConfigResponse) => any;
-}
-export interface SelectResourceConfigRequest {
-    /**
-     * <p>The SQL query <code>SELECT</code> command.</p>
-     */
-    Expression: string | undefined;
-    /**
-     * <p>The maximum number of query results returned on each page. </p>
-     */
-    Limit?: number;
-    /**
-     * <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response. </p>
-     */
-    NextToken?: string;
-}
-export declare namespace SelectResourceConfigRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: SelectResourceConfigRequest) => any;
-}
-export interface SelectResourceConfigResponse {
-    /**
-     * <p>Returns the results for the SQL query.</p>
-     */
-    Results?: string[];
-    /**
-     * <p>Returns the <code>QueryInfo</code> object.</p>
-     */
-    QueryInfo?: QueryInfo;
-    /**
-     * <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response. </p>
-     */
-    NextToken?: string;
-}
-export declare namespace SelectResourceConfigResponse {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: SelectResourceConfigResponse) => any;
-}
-/**
- * <p></p>
- */
-export interface StartConfigRulesEvaluationRequest {
-    /**
-     * <p>The list of names of Config rules that you want to run
-     * 			evaluations for.</p>
-     */
-    ConfigRuleNames?: string[];
-}
-export declare namespace StartConfigRulesEvaluationRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: StartConfigRulesEvaluationRequest) => any;
-}
-/**
- * <p>The output when you start the evaluation for the specified Config rule.</p>
- */
-export interface StartConfigRulesEvaluationResponse {
-}
-export declare namespace StartConfigRulesEvaluationResponse {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: StartConfigRulesEvaluationResponse) => any;
-}
-/**
- * <p>The input for the <a>StartConfigurationRecorder</a>
- * 			action.</p>
- */
-export interface StartConfigurationRecorderRequest {
-    /**
-     * <p>The name of the recorder object that records each configuration
-     * 			change made to the resources.</p>
-     */
-    ConfigurationRecorderName: string | undefined;
-}
-export declare namespace StartConfigurationRecorderRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: StartConfigurationRecorderRequest) => any;
-}
-export interface StartRemediationExecutionRequest {
-    /**
-     * <p>The list of names of Config rules that you want to run remediation execution for.</p>
-     */
-    ConfigRuleName: string | undefined;
-    /**
-     * <p>A list of resource keys to be processed with the current request. Each element in the list consists of the resource type and resource ID. </p>
-     */
-    ResourceKeys: ResourceKey[] | undefined;
-}
-export declare namespace StartRemediationExecutionRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: StartRemediationExecutionRequest) => any;
-}
-export interface StartRemediationExecutionResponse {
-    /**
-     * <p>Returns a failure message. For example, the resource is already compliant.</p>
-     */
-    FailureMessage?: string;
-    /**
-     * <p>For resources that have failed to start execution, the API returns a resource key object.</p>
-     */
-    FailedItems?: ResourceKey[];
-}
-export declare namespace StartRemediationExecutionResponse {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: StartRemediationExecutionResponse) => any;
-}
-/**
- * <p>The input for the <a>StopConfigurationRecorder</a> action.</p>
- */
-export interface StopConfigurationRecorderRequest {
-    /**
-     * <p>The name of the recorder object that records each configuration change made to the resources.</p>
-     */
-    ConfigurationRecorderName: string | undefined;
-}
-export declare namespace StopConfigurationRecorderRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: StopConfigurationRecorderRequest) => any;
-}
-export interface TagResourceRequest {
-    /**
-     * <p>The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the supported resources are <code>ConfigRule</code>, <code>ConfigurationAggregator</code> and <code>AggregatorAuthorization</code>.</p>
-     */
-    ResourceArn: string | undefined;
-    /**
-     * <p>An array of tag object.</p>
-     */
-    Tags: Tag[] | undefined;
-}
-export declare namespace TagResourceRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: TagResourceRequest) => any;
-}
-export interface UntagResourceRequest {
-    /**
-     * <p>The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the supported resources are <code>ConfigRule</code>, <code>ConfigurationAggregator</code> and <code>AggregatorAuthorization</code>.</p>
-     */
-    ResourceArn: string | undefined;
-    /**
-     * <p>The keys of the tags to be removed.</p>
-     */
-    TagKeys: string[] | undefined;
-}
-export declare namespace UntagResourceRequest {
-    /**
-     * @internal
-     */
-    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
-}

package/dist/types/pagination/DescribeAggregateComplianceByConfigRulesPaginator.d.ts

@@ -1,4 +0,0 @@
-import { DescribeAggregateComplianceByConfigRulesCommandInput, DescribeAggregateComplianceByConfigRulesCommandOutput } from "../commands/DescribeAggregateComplianceByConfigRulesCommand";
-import { ConfigServicePaginationConfiguration } from "./Interfaces";
-import { Paginator } from "@aws-sdk/types";
-export declare function paginateDescribeAggregateComplianceByConfigRules(config: ConfigServicePaginationConfiguration, input: DescribeAggregateComplianceByConfigRulesCommandInput, ...additionalArguments: any): Paginator<DescribeAggregateComplianceByConfigRulesCommandOutput>;