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

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

@@ -0,0 +1,48 @@
+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 { PutConfigurationRecorderRequest } from "../models/models_0";
+export interface PutConfigurationRecorderCommandInput extends PutConfigurationRecorderRequest {
+}
+export interface PutConfigurationRecorderCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Creates a new configuration recorder to record the selected
+ * 			resource configurations.</p>
+ * 		       <p>You can use this action to change the role <code>roleARN</code>
+ * 			or the <code>recordingGroup</code> of an existing recorder. To
+ * 			change the role, call the action on the existing configuration
+ * 			recorder and specify a role.</p>
+ * 		       <note>
+ * 			         <p>Currently, you can specify only one configuration recorder
+ * 				per region in your account.</p>
+ * 			         <p>If <code>ConfigurationRecorder</code> does not have the
+ * 					<b>recordingGroup</b> parameter
+ * 				specified, the default is to record all supported resource
+ * 				types.</p>
+ * 		       </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutConfigurationRecorderCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutConfigurationRecorderCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutConfigurationRecorderCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutConfigurationRecorderCommandInput} for command's `input` shape.
+ * @see {@link PutConfigurationRecorderCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutConfigurationRecorderCommand extends $Command<PutConfigurationRecorderCommandInput, PutConfigurationRecorderCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutConfigurationRecorderCommandInput;
+    constructor(input: PutConfigurationRecorderCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationRecorderCommandInput, PutConfigurationRecorderCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutConformancePackCommand.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 { PutConformancePackRequest, PutConformancePackResponse } from "../models/models_0";
+export interface PutConformancePackCommandInput extends PutConformancePackRequest {
+}
+export interface PutConformancePackCommandOutput extends PutConformancePackResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates or updates a conformance pack. A conformance pack is a collection of Config rules that can be easily deployed in an account and a region and across Amazon Web Services Organization.</p>
+ * 		       <p>This API creates a service linked role <code>AWSServiceRoleForConfigConforms</code> in your account.
+ * 		The service linked role is created only when the role does not exist in your account. </p>
+ * 		       <note>
+ *             <p>You must specify either the <code>TemplateS3Uri</code> or the <code>TemplateBody</code> parameter, but not both.
+ * 			If you provide both Config uses the <code>TemplateS3Uri</code> parameter and ignores the <code>TemplateBody</code> parameter.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutConformancePackCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutConformancePackCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutConformancePackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutConformancePackCommandInput} for command's `input` shape.
+ * @see {@link PutConformancePackCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutConformancePackCommand extends $Command<PutConformancePackCommandInput, PutConformancePackCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutConformancePackCommandInput;
+    constructor(input: PutConformancePackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConformancePackCommandInput, PutConformancePackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutDeliveryChannelCommand.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 { PutDeliveryChannelRequest } from "../models/models_0";
+export interface PutDeliveryChannelCommandInput extends PutDeliveryChannelRequest {
+}
+export interface PutDeliveryChannelCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Creates a delivery channel object to deliver configuration
+ * 			information to an Amazon S3 bucket and Amazon SNS topic.</p>
+ * 		       <p>Before you can create a delivery channel, you must create a
+ * 			configuration recorder.</p>
+ * 		       <p>You can use this action to change the Amazon S3 bucket or an
+ * 			Amazon SNS topic of the existing delivery channel. To change the
+ * 			Amazon S3 bucket or an Amazon SNS topic, call this action and
+ * 			specify the changed values for the S3 bucket and the SNS topic. If
+ * 			you specify a different value for either the S3 bucket or the SNS
+ * 			topic, this action will keep the existing value for the parameter
+ * 			that is not changed.</p>
+ * 		       <note>
+ * 			         <p>You can have only one delivery channel per region in your
+ * 				account.</p>
+ *
+ *
+ * 		       </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutDeliveryChannelCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutDeliveryChannelCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutDeliveryChannelCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutDeliveryChannelCommandInput} for command's `input` shape.
+ * @see {@link PutDeliveryChannelCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutDeliveryChannelCommand extends $Command<PutDeliveryChannelCommandInput, PutDeliveryChannelCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutDeliveryChannelCommandInput;
+    constructor(input: PutDeliveryChannelCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDeliveryChannelCommandInput, PutDeliveryChannelCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+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 { PutEvaluationsRequest, PutEvaluationsResponse } from "../models/models_0";
+export interface PutEvaluationsCommandInput extends PutEvaluationsRequest {
+}
+export interface PutEvaluationsCommandOutput extends PutEvaluationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Used by an Lambda function to deliver evaluation results to
+ * 			Config. This action is required in every Lambda function
+ * 			that is invoked by an Config rule.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutEvaluationsCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutEvaluationsCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutEvaluationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutEvaluationsCommandInput} for command's `input` shape.
+ * @see {@link PutEvaluationsCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutEvaluationsCommand extends $Command<PutEvaluationsCommandInput, PutEvaluationsCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutEvaluationsCommandInput;
+    constructor(input: PutEvaluationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEvaluationsCommandInput, PutEvaluationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutExternalEvaluationCommand.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 { PutExternalEvaluationRequest, PutExternalEvaluationResponse } from "../models/models_0";
+export interface PutExternalEvaluationCommandInput extends PutExternalEvaluationRequest {
+}
+export interface PutExternalEvaluationCommandOutput extends PutExternalEvaluationResponse, __MetadataBearer {
+}
+/**
+ * <p>Add or updates the evaluations for process checks.
+ * 			This API checks if the rule is a process check when the name of the Config rule is provided.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutExternalEvaluationCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutExternalEvaluationCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutExternalEvaluationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutExternalEvaluationCommandInput} for command's `input` shape.
+ * @see {@link PutExternalEvaluationCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutExternalEvaluationCommand extends $Command<PutExternalEvaluationCommandInput, PutExternalEvaluationCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutExternalEvaluationCommandInput;
+    constructor(input: PutExternalEvaluationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutExternalEvaluationCommandInput, PutExternalEvaluationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,56 @@
+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 { PutOrganizationConfigRuleRequest, PutOrganizationConfigRuleResponse } from "../models/models_0";
+export interface PutOrganizationConfigRuleCommandInput extends PutOrganizationConfigRuleRequest {
+}
+export interface PutOrganizationConfigRuleCommandOutput extends PutOrganizationConfigRuleResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds or updates organization config rule for your entire organization evaluating whether your Amazon Web Services resources comply with your
+ * 			desired configurations.</p>
+ * 	        <p> Only a master account and a delegated administrator can create or update an organization config rule.
+ * 		When calling this API with a delegated administrator, you must ensure Organizations
+ * 		<code>ListDelegatedAdministrator</code> permissions are added. </p>
+ * 		       <p>This API enables organization service access through the <code>EnableAWSServiceAccess</code> action and creates a service linked
+ * 			role <code>AWSServiceRoleForConfigMultiAccountSetup</code> in the master or delegated administrator account of your organization.
+ * 			The service linked role is created only when the role does not exist in the caller account.
+ * 			Config verifies the existence of role with <code>GetRole</code> action.</p>
+ * 		       <p>To use this API with delegated administrator, register a delegated administrator by calling Amazon Web Services Organization
+ * 			<code>register-delegated-administrator</code> for <code>config-multiaccountsetup.amazonaws.com</code>. </p>
+ * 		       <p>You can use this action to create both custom Config rules and Config managed rules.
+ * 			If you are adding a new custom Config rule, you must first create Lambda function in the master account or a delegated
+ * 			administrator that the rule invokes to evaluate your resources. You also need to create an IAM role in the managed-account that can be assumed by the Lambda function.
+ * 			When you use the <code>PutOrganizationConfigRule</code> action to add the rule to Config, you must
+ * 			specify the Amazon Resource Name (ARN) that Lambda assigns to the function.
+ * 			If you are adding an Config managed rule, specify the rule's identifier for the <code>RuleIdentifier</code> key.</p>
+ * 		       <p>The maximum number of organization config rules that Config supports is 150 and 3 delegated administrator per organization. </p>
+ * 		       <note>
+ *             <p>Prerequisite: Ensure you call <code>EnableAllFeatures</code> API to enable all features in an organization.</p>
+ * 			         <p>Specify either <code>OrganizationCustomRuleMetadata</code> or <code>OrganizationManagedRuleMetadata</code>.</p>
+ * 			      </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutOrganizationConfigRuleCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutOrganizationConfigRuleCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutOrganizationConfigRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutOrganizationConfigRuleCommandInput} for command's `input` shape.
+ * @see {@link PutOrganizationConfigRuleCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutOrganizationConfigRuleCommand extends $Command<PutOrganizationConfigRuleCommandInput, PutOrganizationConfigRuleCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutOrganizationConfigRuleCommandInput;
+    constructor(input: PutOrganizationConfigRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutOrganizationConfigRuleCommandInput, PutOrganizationConfigRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,55 @@
+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 { PutOrganizationConformancePackRequest, PutOrganizationConformancePackResponse } from "../models/models_0";
+export interface PutOrganizationConformancePackCommandInput extends PutOrganizationConformancePackRequest {
+}
+export interface PutOrganizationConformancePackCommandOutput extends PutOrganizationConformancePackResponse, __MetadataBearer {
+}
+/**
+ * <p>Deploys conformance packs across member accounts in an Amazon Web Services Organization.</p>
+ * 		       <p>Only a master account and a delegated administrator can call this API.
+ * 			When calling this API with a delegated administrator, you must ensure Organizations
+ * 			<code>ListDelegatedAdministrator</code> permissions are added.</p>
+ * 		       <p>This API enables organization service access for <code>config-multiaccountsetup.amazonaws.com</code>
+ * 			through the <code>EnableAWSServiceAccess</code> action and creates a
+ * 			service linked role <code>AWSServiceRoleForConfigMultiAccountSetup</code> in the master or delegated administrator account of your organization.
+ * 			The service linked role is created only when the role does not exist in the caller account.
+ * 			To use this API with delegated administrator, register a delegated administrator by calling Amazon Web Services Organization
+ * 			<code>register-delegate-admin</code> for <code>config-multiaccountsetup.amazonaws.com</code>.</p>
+ *
+ *
+ *
+ * 		       <note>
+ * 			         <p>Prerequisite: Ensure you call <code>EnableAllFeatures</code> API to enable all features in an organization.</p>
+ * 			         <p>You must specify either the <code>TemplateS3Uri</code> or the <code>TemplateBody</code> parameter, but not both.
+ * 			If you provide both Config uses the <code>TemplateS3Uri</code> parameter and ignores the <code>TemplateBody</code> parameter.</p>
+ * 			         <p>Config sets the state of a conformance pack to CREATE_IN_PROGRESS and UPDATE_IN_PROGRESS until the conformance pack is created or updated.
+ * 				You cannot update a conformance pack while it is in this state.</p>
+ * 			         <p>You can create 50 conformance packs with 25 Config rules in each pack and 3 delegated administrator per organization. </p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutOrganizationConformancePackCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutOrganizationConformancePackCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutOrganizationConformancePackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutOrganizationConformancePackCommandInput} for command's `input` shape.
+ * @see {@link PutOrganizationConformancePackCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutOrganizationConformancePackCommand extends $Command<PutOrganizationConformancePackCommandInput, PutOrganizationConformancePackCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutOrganizationConformancePackCommandInput;
+    constructor(input: PutOrganizationConformancePackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutOrganizationConformancePackCommandInput, PutOrganizationConformancePackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,45 @@
+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 { PutRemediationConfigurationsRequest, PutRemediationConfigurationsResponse } from "../models/models_0";
+export interface PutRemediationConfigurationsCommandInput extends PutRemediationConfigurationsRequest {
+}
+export interface PutRemediationConfigurationsCommandOutput extends PutRemediationConfigurationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds or updates the remediation configuration with a specific Config rule with the
+ * 			selected target or action.
+ * 			The API creates the <code>RemediationConfiguration</code> object for the Config rule.
+ * 		The Config rule must already exist for you to add a remediation configuration.
+ * 		The target (SSM document) must exist and have permissions to use the target. </p>
+ * 		       <note>
+ *             <p>If you make backward incompatible changes to the SSM document,
+ * 			you must call this again to ensure the remediations can run.</p>
+ * 			         <p>This API does not support adding remediation configurations for service-linked Config Rules such as Organization Config rules,
+ * 				the rules deployed by conformance packs, and rules deployed by Amazon Web Services Security Hub.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutRemediationConfigurationsCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutRemediationConfigurationsCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutRemediationConfigurationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutRemediationConfigurationsCommandInput} for command's `input` shape.
+ * @see {@link PutRemediationConfigurationsCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutRemediationConfigurationsCommand extends $Command<PutRemediationConfigurationsCommandInput, PutRemediationConfigurationsCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutRemediationConfigurationsCommandInput;
+    constructor(input: PutRemediationConfigurationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRemediationConfigurationsCommandInput, PutRemediationConfigurationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutRemediationExceptionsCommand.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 { PutRemediationExceptionsRequest, PutRemediationExceptionsResponse } from "../models/models_0";
+export interface PutRemediationExceptionsCommandInput extends PutRemediationExceptionsRequest {
+}
+export interface PutRemediationExceptionsCommandOutput extends PutRemediationExceptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>A remediation exception is when a specific resource is no longer considered for auto-remediation.
+ * 			This API adds a new exception or updates an existing exception for a specific resource with a specific Config rule. </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, PutRemediationExceptionsCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutRemediationExceptionsCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutRemediationExceptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutRemediationExceptionsCommandInput} for command's `input` shape.
+ * @see {@link PutRemediationExceptionsCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutRemediationExceptionsCommand extends $Command<PutRemediationExceptionsCommandInput, PutRemediationExceptionsCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutRemediationExceptionsCommandInput;
+    constructor(input: PutRemediationExceptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRemediationExceptionsCommandInput, PutRemediationExceptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,44 @@
+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 { PutResourceConfigRequest } from "../models/models_1";
+export interface PutResourceConfigCommandInput extends PutResourceConfigRequest {
+}
+export interface PutResourceConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Records the configuration state for the resource provided in the request.
+ *
+ * 			The configuration state of a resource is represented in Config as Configuration Items.
+ * 			Once this API records the configuration item, you can retrieve the list of configuration items for the custom resource type using existing Config APIs. </p>
+ * 		       <note>
+ *             <p>The custom resource type must be registered with CloudFormation. This API accepts the configuration item registered with CloudFormation.</p>
+ * 			         <p>When you call this API, Config only stores configuration state of the resource provided in the request. This API does not change or remediate the configuration of the resource.
+ * 				</p>
+ * 		          <p>Write-only schema properites are not recorded as part of the published configuration item.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutResourceConfigCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutResourceConfigCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutResourceConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutResourceConfigCommandInput} for command's `input` shape.
+ * @see {@link PutResourceConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutResourceConfigCommand extends $Command<PutResourceConfigCommandInput, PutResourceConfigCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutResourceConfigCommandInput;
+    constructor(input: PutResourceConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResourceConfigCommandInput, PutResourceConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,45 @@
+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 { PutRetentionConfigurationRequest, PutRetentionConfigurationResponse } from "../models/models_1";
+export interface PutRetentionConfigurationCommandInput extends PutRetentionConfigurationRequest {
+}
+export interface PutRetentionConfigurationCommandOutput extends PutRetentionConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates and updates the retention configuration with details
+ * 			about retention period (number of days) that Config stores your
+ * 			historical information. The API creates the
+ * 				<code>RetentionConfiguration</code> object and names the object
+ * 			as <b>default</b>. When you have a
+ * 				<code>RetentionConfiguration</code> object named <b>default</b>, calling the API modifies the
+ * 			default object. </p>
+ * 		       <note>
+ * 			         <p>Currently, Config supports only one retention
+ * 				configuration per region in your account.</p>
+ * 		       </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, PutRetentionConfigurationCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutRetentionConfigurationCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutRetentionConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutRetentionConfigurationCommandInput} for command's `input` shape.
+ * @see {@link PutRetentionConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutRetentionConfigurationCommand extends $Command<PutRetentionConfigurationCommandInput, PutRetentionConfigurationCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutRetentionConfigurationCommandInput;
+    constructor(input: PutRetentionConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutRetentionConfigurationCommandInput, PutRetentionConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutStoredQueryCommand.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 { PutStoredQueryRequest, PutStoredQueryResponse } from "../models/models_1";
+export interface PutStoredQueryCommandInput extends PutStoredQueryRequest {
+}
+export interface PutStoredQueryCommandOutput extends PutStoredQueryResponse, __MetadataBearer {
+}
+/**
+ * <p>Saves a new query or updates an existing saved query. The <code>QueryName</code> must be unique for a single Amazon Web Services account and a single Amazon Web Services Region.
+ * 			You can create upto 300 queries in 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, PutStoredQueryCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, PutStoredQueryCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new PutStoredQueryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutStoredQueryCommandInput} for command's `input` shape.
+ * @see {@link PutStoredQueryCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutStoredQueryCommand extends $Command<PutStoredQueryCommandInput, PutStoredQueryCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: PutStoredQueryCommandInput;
+    constructor(input: PutStoredQueryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutStoredQueryCommandInput, PutStoredQueryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,48 @@
+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 { SelectAggregateResourceConfigRequest, SelectAggregateResourceConfigResponse } from "../models/models_1";
+export interface SelectAggregateResourceConfigCommandInput extends SelectAggregateResourceConfigRequest {
+}
+export interface SelectAggregateResourceConfigCommandOutput extends SelectAggregateResourceConfigResponse, __MetadataBearer {
+}
+/**
+ * <p>Accepts a structured query language (SQL) SELECT command and an aggregator to query configuration state of Amazon Web Services resources across multiple accounts and regions,
+ * 			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>
+ *
+ * 		       <note>
+ * 			         <p>If you run an aggregation query (i.e., using <code>GROUP BY</code> or using aggregate functions such as <code>COUNT</code>; e.g., <code>SELECT resourceId, COUNT(*) WHERE resourceType = 'AWS::IAM::Role' GROUP BY resourceId</code>)
+ * 				and do not specify the <code>MaxResults</code> or the <code>Limit</code> query parameters, the default page size is set to 500.</p>
+ *
+ * 			         <p>If you run a non-aggregation query (i.e., not using <code>GROUP BY</code> or aggregate function; e.g., <code>SELECT * WHERE resourceType = 'AWS::IAM::Role'</code>)
+ * 				and do not specify the <code>MaxResults</code> or the <code>Limit</code> query parameters, the default page size is set to 25.</p>
+ * 		       </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ConfigServiceClient, SelectAggregateResourceConfigCommand } from "@aws-sdk/client-config-service"; // ES Modules import
+ * // const { ConfigServiceClient, SelectAggregateResourceConfigCommand } = require("@aws-sdk/client-config-service"); // CommonJS import
+ * const client = new ConfigServiceClient(config);
+ * const command = new SelectAggregateResourceConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SelectAggregateResourceConfigCommandInput} for command's `input` shape.
+ * @see {@link SelectAggregateResourceConfigCommandOutput} for command's `response` shape.
+ * @see {@link ConfigServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SelectAggregateResourceConfigCommand extends $Command<SelectAggregateResourceConfigCommandInput, SelectAggregateResourceConfigCommandOutput, ConfigServiceClientResolvedConfig> {
+    readonly input: SelectAggregateResourceConfigCommandInput;
+    constructor(input: SelectAggregateResourceConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ConfigServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SelectAggregateResourceConfigCommandInput, SelectAggregateResourceConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}