@aws-sdk/client-cloudformation 3.34.0 → 3.37.0

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

@@ -0,0 +1,64 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { RollbackStackInput, RollbackStackOutput } from "../models/models_0";
+export interface RollbackStackCommandInput extends RollbackStackInput {
+}
+export interface RollbackStackCommandOutput extends RollbackStackOutput, __MetadataBearer {
+}
+/**
+ * <p>When specifying <code>RollbackStack</code>, you preserve the state of previously provisioned resources when an operation fails. You can check the status of the stack through the <a>DescribeStacks</a> API.</p>
+ *          <p>Rolls back the specified stack to the last known stable state from <code>CREATE_FAILED</code> or <code>UPDATE_FAILED</code> stack statuses.</p>
+ *          <p>This operation will delete a stack if it doesn't contain a last known stable state. A last known stable state includes any status in a <code>*_COMPLETE</code>. This includes the following stack statuses.</p>
+ *          <ul>
+ *             <li>
+ *                <p>
+ *                   <code>CREATE_COMPLETE</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>UPDATE_COMPLETE</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>UPDATE_ROLLBACK_COMPLETE</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>IMPORT_COMPLETE</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <code>IMPORT_ROLLBACK_COMPLETE</code>
+ *                </p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, RollbackStackCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, RollbackStackCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new RollbackStackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RollbackStackCommandInput} for command's `input` shape.
+ * @see {@link RollbackStackCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RollbackStackCommand extends $Command<RollbackStackCommandInput, RollbackStackCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: RollbackStackCommandInput;
+    constructor(input: RollbackStackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RollbackStackCommandInput, RollbackStackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetStackPolicyCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { SetStackPolicyInput } from "../models/models_0";
+export interface SetStackPolicyCommandInput extends SetStackPolicyInput {
+}
+export interface SetStackPolicyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Sets a stack policy for a specified stack.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, SetStackPolicyCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, SetStackPolicyCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new SetStackPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetStackPolicyCommandInput} for command's `input` shape.
+ * @see {@link SetStackPolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetStackPolicyCommand extends $Command<SetStackPolicyCommandInput, SetStackPolicyCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: SetStackPolicyCommandInput;
+    constructor(input: SetStackPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetStackPolicyCommandInput, SetStackPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { SetTypeConfigurationInput, SetTypeConfigurationOutput } from "../models/models_0";
+export interface SetTypeConfigurationCommandInput extends SetTypeConfigurationInput {
+}
+export interface SetTypeConfigurationCommandOutput extends SetTypeConfigurationOutput, __MetadataBearer {
+}
+/**
+ * <p>Specifies the configuration data for a registered CloudFormation extension, in the given
+ *          account and region.</p>
+ *          <p>To view the current configuration data for an extension, refer to the
+ *             <code>ConfigurationSchema</code> element of <a href="AWSCloudFormation/latest/APIReference/API_DescribeType.html">DescribeType</a>.
+ *          For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/registry-register.html#registry-set-configuration">Configuring extensions at the account level</a> in the
+ *             <i>CloudFormation User Guide</i>.</p>
+ *          <important>
+ *             <p>It is strongly recommended that you use dynamic references to restrict sensitive
+ *             configuration definitions, such as third-party credentials. For more details on dynamic
+ *             references, see <a href="https://docs.aws.amazon.com/">Using dynamic references to specify
+ *                template values</a> in the <i>CloudFormation User
+ *             Guide</i>.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, SetTypeConfigurationCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, SetTypeConfigurationCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new SetTypeConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetTypeConfigurationCommandInput} for command's `input` shape.
+ * @see {@link SetTypeConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetTypeConfigurationCommand extends $Command<SetTypeConfigurationCommandInput, SetTypeConfigurationCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: SetTypeConfigurationCommandInput;
+    constructor(input: SetTypeConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetTypeConfigurationCommandInput, SetTypeConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetTypeDefaultVersionCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { SetTypeDefaultVersionInput, SetTypeDefaultVersionOutput } from "../models/models_0";
+export interface SetTypeDefaultVersionCommandInput extends SetTypeDefaultVersionInput {
+}
+export interface SetTypeDefaultVersionCommandOutput extends SetTypeDefaultVersionOutput, __MetadataBearer {
+}
+/**
+ * <p>Specify the default version of an extension. The default version of an extension will be
+ *          used in CloudFormation operations.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, SetTypeDefaultVersionCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, SetTypeDefaultVersionCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new SetTypeDefaultVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetTypeDefaultVersionCommandInput} for command's `input` shape.
+ * @see {@link SetTypeDefaultVersionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetTypeDefaultVersionCommand extends $Command<SetTypeDefaultVersionCommandInput, SetTypeDefaultVersionCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: SetTypeDefaultVersionCommandInput;
+    constructor(input: SetTypeDefaultVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetTypeDefaultVersionCommandInput, SetTypeDefaultVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SignalResourceCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { SignalResourceInput } from "../models/models_0";
+export interface SignalResourceCommandInput extends SignalResourceInput {
+}
+export interface SignalResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Sends a signal to the specified resource with a success or failure status. You can
+ *          use the SignalResource API in conjunction with a creation policy or update policy.
+ *          CloudFormation doesn't proceed with a stack creation or update until resources receive the
+ *          required number of signals or the timeout period is exceeded. The SignalResource API is
+ *          useful in cases where you want to send signals from anywhere other than an Amazon EC2
+ *          instance.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, SignalResourceCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, SignalResourceCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new SignalResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SignalResourceCommandInput} for command's `input` shape.
+ * @see {@link SignalResourceCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SignalResourceCommand extends $Command<SignalResourceCommandInput, SignalResourceCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: SignalResourceCommandInput;
+    constructor(input: SignalResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SignalResourceCommandInput, SignalResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StopStackSetOperationCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { StopStackSetOperationInput, StopStackSetOperationOutput } from "../models/models_0";
+export interface StopStackSetOperationCommandInput extends StopStackSetOperationInput {
+}
+export interface StopStackSetOperationCommandOutput extends StopStackSetOperationOutput, __MetadataBearer {
+}
+/**
+ * <p>Stops an in-progress operation on a stack set and its associated stack instances. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, StopStackSetOperationCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, StopStackSetOperationCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new StopStackSetOperationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopStackSetOperationCommandInput} for command's `input` shape.
+ * @see {@link StopStackSetOperationCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopStackSetOperationCommand extends $Command<StopStackSetOperationCommandInput, StopStackSetOperationCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: StopStackSetOperationCommandInput;
+    constructor(input: StopStackSetOperationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopStackSetOperationCommandInput, StopStackSetOperationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,58 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { TestTypeInput, TestTypeOutput } from "../models/models_0";
+export interface TestTypeCommandInput extends TestTypeInput {
+}
+export interface TestTypeCommandOutput extends TestTypeOutput, __MetadataBearer {
+}
+/**
+ * <p>Tests a registered extension to make sure it meets all necessary requirements for being
+ *          published in the CloudFormation registry.</p>
+ *          <ul>
+ *             <li>
+ *                <p>For resource types, this includes passing all contracts tests defined for the
+ *                type.</p>
+ *             </li>
+ *             <li>
+ *                <p>For modules, this includes determining if the module's model meets all necessary
+ *                requirements.</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-testing">Testing your public extension prior to publishing</a> in the
+ *             <i>CloudFormation CLI User Guide</i>.</p>
+ *          <p>If you do not specify a version, CloudFormation uses the default version of the
+ *          extension in your account and region for testing.</p>
+ *          <p>To perform testing, CloudFormation assumes the execution role specified when the type
+ *          was registered. For more information, see <a href="AWSCloudFormation/latest/APIReference/API_RegisterType.html">RegisterType</a>.</p>
+ *          <p>Once you've initiated testing on an extension using <code>TestType</code>, you can use
+ *             <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html">DescribeType</a> to monitor the current test status and test
+ *          status description for the extension.</p>
+ *          <p>An extension must have a test status of <code>PASSED</code> before it can be published.
+ *          For more information, see <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-publish.html">Publishing extensions to make them available for public use</a>
+ *          in the <i>CloudFormation CLI User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, TestTypeCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, TestTypeCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new TestTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TestTypeCommandInput} for command's `input` shape.
+ * @see {@link TestTypeCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TestTypeCommand extends $Command<TestTypeCommandInput, TestTypeCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: TestTypeCommandInput;
+    constructor(input: TestTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestTypeCommandInput, TestTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateStackCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { UpdateStackInput, UpdateStackOutput } from "../models/models_0";
+export interface UpdateStackCommandInput extends UpdateStackInput {
+}
+export interface UpdateStackCommandOutput extends UpdateStackOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates a stack as specified in the template. After the call completes successfully,
+ *          the stack update starts. You can check the status of the stack via the <a>DescribeStacks</a> action.</p>
+ *          <p>To get a copy of the template for an existing stack, you can use the <a>GetTemplate</a> action.</p>
+ *          <p>For more information about creating an update template, updating a stack, and
+ *          monitoring the progress of the update, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks.html">Updating a
+ *             Stack</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, UpdateStackCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, UpdateStackCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new UpdateStackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateStackCommandInput} for command's `input` shape.
+ * @see {@link UpdateStackCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateStackCommand extends $Command<UpdateStackCommandInput, UpdateStackCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: UpdateStackCommandInput;
+    constructor(input: UpdateStackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateStackCommandInput, UpdateStackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { UpdateStackInstancesInput, UpdateStackInstancesOutput } from "../models/models_0";
+export interface UpdateStackInstancesCommandInput extends UpdateStackInstancesInput {
+}
+export interface UpdateStackInstancesCommandOutput extends UpdateStackInstancesOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the parameter values for stack instances for the specified accounts, within
+ *          the specified Regions. A stack instance refers to a stack in a specific account and Region. </p>
+ *          <p>You can only update stack instances in Regions and accounts where they already exist;
+ *          to create additional stack instances, use <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackInstances.html">CreateStackInstances</a>. </p>
+ *          <p>During stack set updates, any parameters overridden for a stack instance are not
+ *          updated, but retain their overridden value.</p>
+ *          <p>You can only update the parameter <i>values</i> that are specified in
+ *          the stack set; to add or delete a parameter itself, use <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html">UpdateStackSet</a> to update the stack set template. If you add a parameter to a
+ *          template, before you can override the parameter value specified in the stack set you must
+ *          first use <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html">UpdateStackSet</a> to update all stack instances with the updated template and
+ *          parameter value specified in the stack set. Once a stack instance has been updated with the
+ *          new parameter, you can then override the parameter value using
+ *             <code>UpdateStackInstances</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, UpdateStackInstancesCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, UpdateStackInstancesCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new UpdateStackInstancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateStackInstancesCommandInput} for command's `input` shape.
+ * @see {@link UpdateStackInstancesCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateStackInstancesCommand extends $Command<UpdateStackInstancesCommandInput, UpdateStackInstancesCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: UpdateStackInstancesCommandInput;
+    constructor(input: UpdateStackInstancesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateStackInstancesCommandInput, UpdateStackInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateStackSetCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { UpdateStackSetInput, UpdateStackSetOutput } from "../models/models_0";
+export interface UpdateStackSetCommandInput extends UpdateStackSetInput {
+}
+export interface UpdateStackSetCommandOutput extends UpdateStackSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the stack set, and associated stack instances in the specified accounts and
+ *          Regions.</p>
+ *          <p>Even if the stack set operation created by updating the stack set fails (completely
+ *          or partially, below or above a specified failure tolerance), the stack set is updated with
+ *          your changes. Subsequent <a>CreateStackInstances</a> calls on the specified
+ *          stack set use the updated stack set.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, UpdateStackSetCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, UpdateStackSetCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new UpdateStackSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateStackSetCommandInput} for command's `input` shape.
+ * @see {@link UpdateStackSetCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateStackSetCommand extends $Command<UpdateStackSetCommandInput, UpdateStackSetCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: UpdateStackSetCommandInput;
+    constructor(input: UpdateStackSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateStackSetCommandInput, UpdateStackSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateTerminationProtectionCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { UpdateTerminationProtectionInput, UpdateTerminationProtectionOutput } from "../models/models_0";
+export interface UpdateTerminationProtectionCommandInput extends UpdateTerminationProtectionInput {
+}
+export interface UpdateTerminationProtectionCommandOutput extends UpdateTerminationProtectionOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates termination protection for the specified stack. If a user attempts to delete
+ *          a stack with termination protection enabled, the operation fails and the stack remains
+ *          unchanged. For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html">Protecting a
+ *             Stack From Being Deleted</a> in the <i>CloudFormation User Guide</i>.</p>
+ *          <p>For <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-nested-stacks.html">nested
+ *             stacks</a>, termination protection is set on the root stack and cannot be changed
+ *          directly on the nested stack.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, UpdateTerminationProtectionCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, UpdateTerminationProtectionCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new UpdateTerminationProtectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateTerminationProtectionCommandInput} for command's `input` shape.
+ * @see {@link UpdateTerminationProtectionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateTerminationProtectionCommand extends $Command<UpdateTerminationProtectionCommandInput, UpdateTerminationProtectionCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: UpdateTerminationProtectionCommandInput;
+    constructor(input: UpdateTerminationProtectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTerminationProtectionCommandInput, UpdateTerminationProtectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ValidateTemplateCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { ValidateTemplateInput, ValidateTemplateOutput } from "../models/models_0";
+export interface ValidateTemplateCommandInput extends ValidateTemplateInput {
+}
+export interface ValidateTemplateCommandOutput extends ValidateTemplateOutput, __MetadataBearer {
+}
+/**
+ * <p>Validates a specified template. CloudFormation first checks if the template is
+ *          valid JSON. If it isn't, CloudFormation checks if the template is valid YAML. If both
+ *          these checks fail, CloudFormation returns a template validation error.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ValidateTemplateCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ValidateTemplateCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ValidateTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ValidateTemplateCommandInput} for command's `input` shape.
+ * @see {@link ValidateTemplateCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ValidateTemplateCommand extends $Command<ValidateTemplateCommandInput, ValidateTemplateCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ValidateTemplateCommandInput;
+    constructor(input: ValidateTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ValidateTemplateCommandInput, ValidateTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/pagination/DescribeAccountLimitsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput } from "../commands/DescribeAccountLimitsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeAccountLimits(config: CloudFormationPaginationConfiguration, input: DescribeAccountLimitsCommandInput, ...additionalArguments: any): Paginator<DescribeAccountLimitsCommandOutput>;

package/dist-types/pagination/DescribeStackEventsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeStackEventsCommandInput, DescribeStackEventsCommandOutput } from "../commands/DescribeStackEventsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeStackEvents(config: CloudFormationPaginationConfiguration, input: DescribeStackEventsCommandInput, ...additionalArguments: any): Paginator<DescribeStackEventsCommandOutput>;

package/dist-types/pagination/DescribeStackResourceDriftsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeStackResourceDriftsCommandInput, DescribeStackResourceDriftsCommandOutput } from "../commands/DescribeStackResourceDriftsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeStackResourceDrifts(config: CloudFormationPaginationConfiguration, input: DescribeStackResourceDriftsCommandInput, ...additionalArguments: any): Paginator<DescribeStackResourceDriftsCommandOutput>;

package/dist-types/pagination/DescribeStacksPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { DescribeStacksCommandInput, DescribeStacksCommandOutput } from "../commands/DescribeStacksCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateDescribeStacks(config: CloudFormationPaginationConfiguration, input: DescribeStacksCommandInput, ...additionalArguments: any): Paginator<DescribeStacksCommandOutput>;

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

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

package/dist-types/pagination/ListChangeSetsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListChangeSetsCommandInput, ListChangeSetsCommandOutput } from "../commands/ListChangeSetsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListChangeSets(config: CloudFormationPaginationConfiguration, input: ListChangeSetsCommandInput, ...additionalArguments: any): Paginator<ListChangeSetsCommandOutput>;

package/dist-types/pagination/ListExportsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListExportsCommandInput, ListExportsCommandOutput } from "../commands/ListExportsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListExports(config: CloudFormationPaginationConfiguration, input: ListExportsCommandInput, ...additionalArguments: any): Paginator<ListExportsCommandOutput>;

package/dist-types/pagination/ListImportsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListImportsCommandInput, ListImportsCommandOutput } from "../commands/ListImportsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListImports(config: CloudFormationPaginationConfiguration, input: ListImportsCommandInput, ...additionalArguments: any): Paginator<ListImportsCommandOutput>;

package/dist-types/pagination/ListStackInstancesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListStackInstancesCommandInput, ListStackInstancesCommandOutput } from "../commands/ListStackInstancesCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListStackInstances(config: CloudFormationPaginationConfiguration, input: ListStackInstancesCommandInput, ...additionalArguments: any): Paginator<ListStackInstancesCommandOutput>;

package/dist-types/pagination/ListStackResourcesPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListStackResourcesCommandInput, ListStackResourcesCommandOutput } from "../commands/ListStackResourcesCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListStackResources(config: CloudFormationPaginationConfiguration, input: ListStackResourcesCommandInput, ...additionalArguments: any): Paginator<ListStackResourcesCommandOutput>;

package/dist-types/pagination/ListStackSetOperationResultsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListStackSetOperationResultsCommandInput, ListStackSetOperationResultsCommandOutput } from "../commands/ListStackSetOperationResultsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListStackSetOperationResults(config: CloudFormationPaginationConfiguration, input: ListStackSetOperationResultsCommandInput, ...additionalArguments: any): Paginator<ListStackSetOperationResultsCommandOutput>;

package/dist-types/pagination/ListStackSetOperationsPaginator.d.ts

@@ -0,0 +1,4 @@
+import { Paginator } from "@aws-sdk/types";
+import { ListStackSetOperationsCommandInput, ListStackSetOperationsCommandOutput } from "../commands/ListStackSetOperationsCommand";
+import { CloudFormationPaginationConfiguration } from "./Interfaces";
+export declare function paginateListStackSetOperations(config: CloudFormationPaginationConfiguration, input: ListStackSetOperationsCommandInput, ...additionalArguments: any): Paginator<ListStackSetOperationsCommandOutput>;