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

package/dist-types/commands/DeleteEvaluationResultsCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DeleteEvaluationResultsRequest, DeleteEvaluationResultsResponse } from "../models/models_0";
+export interface DeleteEvaluationResultsCommandInput extends DeleteEvaluationResultsRequest {
+}
+export interface DeleteEvaluationResultsCommandOutput extends DeleteEvaluationResultsResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes the evaluation results for the specified Config
+ * 			rule. You can specify one Config rule per request. After you
+ * 			delete the evaluation results, you can call the <a>StartConfigRulesEvaluation</a> API to start evaluating
+ * 			your Amazon Web Services resources against the rule.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DeleteEvaluationResultsCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DeleteEvaluationResultsCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DeleteEvaluationResultsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEvaluationResultsCommandInput} for command's `input` shape.
+ * @see {@link DeleteEvaluationResultsCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteEvaluationResultsCommand extends $Command<DeleteEvaluationResultsCommandInput, DeleteEvaluationResultsCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DeleteEvaluationResultsCommandInput;
+    constructor(input: DeleteEvaluationResultsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEvaluationResultsCommandInput, DeleteEvaluationResultsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteOrganizationConfigRuleCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DeleteOrganizationConfigRuleRequest } from "../models/models_0";
+export interface DeleteOrganizationConfigRuleCommandInput extends DeleteOrganizationConfigRuleRequest {
+}
+export interface DeleteOrganizationConfigRuleCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified organization config rule and all of its evaluation results from all member accounts in that organization. </p>
+ * 	        <p>Only a master account and a delegated administrator account can delete an organization config rule.
+ * 		When calling this API with a delegated administrator, you must ensure Organizations
+ * 			<code>ListDelegatedAdministrator</code> permissions are added.</p>
+ * 		       <p>Config sets the state of a rule to DELETE_IN_PROGRESS until the deletion is complete.
+ * 			You cannot update a rule while it is in this state.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DeleteOrganizationConfigRuleCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DeleteOrganizationConfigRuleCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DeleteOrganizationConfigRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteOrganizationConfigRuleCommandInput} for command's `input` shape.
+ * @see {@link DeleteOrganizationConfigRuleCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteOrganizationConfigRuleCommand extends $Command<DeleteOrganizationConfigRuleCommandInput, DeleteOrganizationConfigRuleCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DeleteOrganizationConfigRuleCommandInput;
+    constructor(input: DeleteOrganizationConfigRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteOrganizationConfigRuleCommandInput, DeleteOrganizationConfigRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteOrganizationConformancePackCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DeleteOrganizationConformancePackRequest } from "../models/models_0";
+export interface DeleteOrganizationConformancePackCommandInput extends DeleteOrganizationConformancePackRequest {
+}
+export interface DeleteOrganizationConformancePackCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified organization conformance pack and all of the config rules and remediation actions from
+ * 			all member accounts in that organization. </p>
+ *          <p> Only a master account or a delegated administrator account can delete an organization conformance pack.
+ * 	When calling this API with a delegated administrator, you must ensure Organizations
+ * 		<code>ListDelegatedAdministrator</code> permissions are added.</p>
+ * 			      <p>Config sets the state of a conformance pack to DELETE_IN_PROGRESS until the deletion is complete.
+ * 				You cannot update a conformance pack while it is in this state. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DeleteOrganizationConformancePackCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DeleteOrganizationConformancePackCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DeleteOrganizationConformancePackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteOrganizationConformancePackCommandInput} for command's `input` shape.
+ * @see {@link DeleteOrganizationConformancePackCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteOrganizationConformancePackCommand extends $Command<DeleteOrganizationConformancePackCommandInput, DeleteOrganizationConformancePackCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DeleteOrganizationConformancePackCommandInput;
+    constructor(input: DeleteOrganizationConformancePackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteOrganizationConformancePackCommandInput, DeleteOrganizationConformancePackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeletePendingAggregationRequestCommand.d.ts

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

package/dist-types/commands/DeleteRemediationConfigurationCommand.d.ts

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

package/dist-types/commands/DeleteRemediationExceptionsCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DeleteRemediationExceptionsRequest, DeleteRemediationExceptionsResponse } from "../models/models_0";
+export interface DeleteRemediationExceptionsCommandInput extends DeleteRemediationExceptionsRequest {
+}
+export interface DeleteRemediationExceptionsCommandOutput extends DeleteRemediationExceptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes one or more remediation exceptions mentioned in the resource keys.</p>
+ * 		       <note>
+ *             <p>Config generates a remediation exception when a problem occurs executing a remediation action to a specific resource.
+ * 			Remediation exceptions blocks auto-remediation until the exception is cleared.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DeleteRemediationExceptionsCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DeleteRemediationExceptionsCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DeleteRemediationExceptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteRemediationExceptionsCommandInput} for command's `input` shape.
+ * @see {@link DeleteRemediationExceptionsCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteRemediationExceptionsCommand extends $Command<DeleteRemediationExceptionsCommandInput, DeleteRemediationExceptionsCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DeleteRemediationExceptionsCommandInput;
+    constructor(input: DeleteRemediationExceptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRemediationExceptionsCommandInput, DeleteRemediationExceptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteResourceConfigCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DeleteResourceConfigRequest } from "../models/models_0";
+export interface DeleteResourceConfigCommandInput extends DeleteResourceConfigRequest {
+}
+export interface DeleteResourceConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Records the configuration state for a custom resource that has been deleted.  This API records a new ConfigurationItem with a ResourceDeleted status. You can retrieve the ConfigurationItems recorded for this resource in your Config History.
+ * 			 </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DeleteResourceConfigCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DeleteResourceConfigCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DeleteResourceConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteResourceConfigCommandInput} for command's `input` shape.
+ * @see {@link DeleteResourceConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteResourceConfigCommand extends $Command<DeleteResourceConfigCommandInput, DeleteResourceConfigCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DeleteResourceConfigCommandInput;
+    constructor(input: DeleteResourceConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResourceConfigCommandInput, DeleteResourceConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteRetentionConfigurationCommand.d.ts

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

package/dist-types/commands/DeleteStoredQueryCommand.d.ts

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

package/dist-types/commands/DeliverConfigSnapshotCommand.d.ts

@@ -0,0 +1,51 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DeliverConfigSnapshotRequest, DeliverConfigSnapshotResponse } from "../models/models_0";
+export interface DeliverConfigSnapshotCommandInput extends DeliverConfigSnapshotRequest {
+}
+export interface DeliverConfigSnapshotCommandOutput extends DeliverConfigSnapshotResponse, __MetadataBearer {
+}
+/**
+ * <p>Schedules delivery of a configuration snapshot to the Amazon S3
+ * 			bucket in the specified delivery channel. After the delivery has
+ * 			started, Config sends the following notifications using an
+ * 			Amazon SNS topic that you have specified.</p>
+ * 		       <ul>
+ *             <li>
+ * 				           <p>Notification of the start of the delivery.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Notification of the completion of the delivery, if the
+ * 					delivery was successfully completed.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Notification of delivery failure, if the delivery
+ * 					failed.</p>
+ * 			         </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DeliverConfigSnapshotCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DeliverConfigSnapshotCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DeliverConfigSnapshotCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeliverConfigSnapshotCommandInput} for command's `input` shape.
+ * @see {@link DeliverConfigSnapshotCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeliverConfigSnapshotCommand extends $Command<DeliverConfigSnapshotCommandInput, DeliverConfigSnapshotCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DeliverConfigSnapshotCommandInput;
+    constructor(input: DeliverConfigSnapshotCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeliverConfigSnapshotCommandInput, DeliverConfigSnapshotCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeAggregateComplianceByConfigRulesCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DescribeAggregateComplianceByConfigRulesRequest, DescribeAggregateComplianceByConfigRulesResponse } from "../models/models_0";
+export interface DescribeAggregateComplianceByConfigRulesCommandInput extends DescribeAggregateComplianceByConfigRulesRequest {
+}
+export interface DescribeAggregateComplianceByConfigRulesCommandOutput extends DescribeAggregateComplianceByConfigRulesResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of compliant and noncompliant rules with the
+ * 			number of resources for compliant and noncompliant rules. Does not display rules that do not have compliance results.
+ * 			</p>
+ * 		       <note>
+ * 			         <p>The results can return an empty result page, but if you
+ * 				have a <code>nextToken</code>, the results are displayed on the next
+ * 				page.</p>
+ * 		       </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DescribeAggregateComplianceByConfigRulesCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DescribeAggregateComplianceByConfigRulesCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DescribeAggregateComplianceByConfigRulesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeAggregateComplianceByConfigRulesCommandInput} for command's `input` shape.
+ * @see {@link DescribeAggregateComplianceByConfigRulesCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeAggregateComplianceByConfigRulesCommand extends $Command<DescribeAggregateComplianceByConfigRulesCommandInput, DescribeAggregateComplianceByConfigRulesCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DescribeAggregateComplianceByConfigRulesCommandInput;
+    constructor(input: DescribeAggregateComplianceByConfigRulesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAggregateComplianceByConfigRulesCommandInput, DescribeAggregateComplianceByConfigRulesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeAggregateComplianceByConformancePacksCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DescribeAggregateComplianceByConformancePacksRequest, DescribeAggregateComplianceByConformancePacksResponse } from "../models/models_0";
+export interface DescribeAggregateComplianceByConformancePacksCommandInput extends DescribeAggregateComplianceByConformancePacksRequest {
+}
+export interface DescribeAggregateComplianceByConformancePacksCommandOutput extends DescribeAggregateComplianceByConformancePacksResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of the conformance packs and their associated compliance status with the count of compliant and noncompliant Config rules within each conformance pack.
+ * 			Also returns the total rule count which includes compliant rules, noncompliant rules, and rules that cannot be evaluated due to insufficient data.</p>
+ * 		       <note>
+ *             <p>The results can return an empty result page, but if you have a <code>nextToken</code>, the results are displayed on the next page.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DescribeAggregateComplianceByConformancePacksCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DescribeAggregateComplianceByConformancePacksCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DescribeAggregateComplianceByConformancePacksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeAggregateComplianceByConformancePacksCommandInput} for command's `input` shape.
+ * @see {@link DescribeAggregateComplianceByConformancePacksCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeAggregateComplianceByConformancePacksCommand extends $Command<DescribeAggregateComplianceByConformancePacksCommandInput, DescribeAggregateComplianceByConformancePacksCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DescribeAggregateComplianceByConformancePacksCommandInput;
+    constructor(input: DescribeAggregateComplianceByConformancePacksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAggregateComplianceByConformancePacksCommandInput, DescribeAggregateComplianceByConformancePacksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeAggregationAuthorizationsCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DescribeAggregationAuthorizationsRequest, DescribeAggregationAuthorizationsResponse } from "../models/models_0";
+export interface DescribeAggregationAuthorizationsCommandInput extends DescribeAggregationAuthorizationsRequest {
+}
+export interface DescribeAggregationAuthorizationsCommandOutput extends DescribeAggregationAuthorizationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of authorizations granted to various aggregator
+ * 			accounts and regions.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DescribeAggregationAuthorizationsCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DescribeAggregationAuthorizationsCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DescribeAggregationAuthorizationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeAggregationAuthorizationsCommandInput} for command's `input` shape.
+ * @see {@link DescribeAggregationAuthorizationsCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeAggregationAuthorizationsCommand extends $Command<DescribeAggregationAuthorizationsCommandInput, DescribeAggregationAuthorizationsCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DescribeAggregationAuthorizationsCommandInput;
+    constructor(input: DescribeAggregationAuthorizationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAggregationAuthorizationsCommandInput, DescribeAggregationAuthorizationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeComplianceByConfigRuleCommand.d.ts

@@ -0,0 +1,67 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ConfigServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ConfigServiceClient";
+import { DescribeComplianceByConfigRuleRequest, DescribeComplianceByConfigRuleResponse } from "../models/models_0";
+export interface DescribeComplianceByConfigRuleCommandInput extends DescribeComplianceByConfigRuleRequest {
+}
+export interface DescribeComplianceByConfigRuleCommandOutput extends DescribeComplianceByConfigRuleResponse, __MetadataBearer {
+}
+/**
+ * <p>Indicates whether the specified Config rules are compliant.
+ * 			If a rule is noncompliant, this action returns the number of Amazon Web Services
+ * 			resources that do not comply with the rule.</p>
+ * 		       <p>A rule is compliant if all of the evaluated resources comply
+ * 			with it. It is noncompliant if any of these resources do not
+ * 			comply.</p>
+ * 		       <p>If Config has no current evaluation results for the rule,
+ * 			it returns <code>INSUFFICIENT_DATA</code>. This result might
+ * 			indicate one of the following conditions:</p>
+ * 		       <ul>
+ *             <li>
+ * 				           <p>Config has never invoked an evaluation for the
+ * 					rule. To check whether it has, use the
+ * 						<code>DescribeConfigRuleEvaluationStatus</code> action
+ * 					to get the <code>LastSuccessfulInvocationTime</code> and
+ * 						<code>LastFailedInvocationTime</code>.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>The rule's Lambda function is failing to send
+ * 					evaluation results to Config. Verify that the role you
+ * 					assigned to your configuration recorder includes the
+ * 						<code>config:PutEvaluations</code> permission. If the
+ * 					rule is a custom rule, verify that the Lambda execution
+ * 					role includes the <code>config:PutEvaluations</code>
+ * 					permission.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>The rule's Lambda function has returned
+ * 						<code>NOT_APPLICABLE</code> for all evaluation results.
+ * 					This can occur if the resources were deleted or removed from
+ * 					the rule's scope.</p>
+ * 			         </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, DescribeComplianceByConfigRuleCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, DescribeComplianceByConfigRuleCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new DescribeComplianceByConfigRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeComplianceByConfigRuleCommandInput} for command's `input` shape.
+ * @see {@link DescribeComplianceByConfigRuleCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeComplianceByConfigRuleCommand extends $Command<DescribeComplianceByConfigRuleCommandInput, DescribeComplianceByConfigRuleCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: DescribeComplianceByConfigRuleCommandInput;
+    constructor(input: DescribeComplianceByConfigRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeComplianceByConfigRuleCommandInput, DescribeComplianceByConfigRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}