@aws-sdk/client-cloudformation 3.34.0 → 3.37.0

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

package/dist-types/commands/DescribeStacksCommand.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 { DescribeStacksInput, DescribeStacksOutput } from "../models/models_0";
+export interface DescribeStacksCommandInput extends DescribeStacksInput {
+}
+export interface DescribeStacksCommandOutput extends DescribeStacksOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the description for the specified stack; if no stack name was specified, then
+ *          it returns the description for all the stacks created.</p>
+ *          <note>
+ *             <p>If the stack does not exist, an <code>ValidationError</code> is
+ *             returned.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStacksCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStacksCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStacksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStacksCommandInput} for command's `input` shape.
+ * @see {@link DescribeStacksCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStacksCommand extends $Command<DescribeStacksCommandInput, DescribeStacksCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStacksCommandInput;
+    constructor(input: DescribeStacksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStacksCommandInput, DescribeStacksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeTypeCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { DescribeTypeInput, DescribeTypeOutput } from "../models/models_0";
+export interface DescribeTypeCommandInput extends DescribeTypeInput {
+}
+export interface DescribeTypeCommandOutput extends DescribeTypeOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns detailed information about an extension that has been registered.</p>
+ *          <p>If you specify a <code>VersionId</code>, <code>DescribeType</code> returns information
+ *          about that specific extension version. Otherwise, it returns information about the default
+ *          extension version.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeTypeCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeTypeCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTypeCommandInput} for command's `input` shape.
+ * @see {@link DescribeTypeCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeTypeCommand extends $Command<DescribeTypeCommandInput, DescribeTypeCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeTypeCommandInput;
+    constructor(input: DescribeTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTypeCommandInput, DescribeTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeTypeRegistrationCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { DescribeTypeRegistrationInput, DescribeTypeRegistrationOutput } from "../models/models_0";
+export interface DescribeTypeRegistrationCommandInput extends DescribeTypeRegistrationInput {
+}
+export interface DescribeTypeRegistrationCommandOutput extends DescribeTypeRegistrationOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns information about an extension's registration, including its current status and
+ *          type and version identifiers.</p>
+ *          <p>When you initiate a registration request using <code>
+ *                <a>RegisterType</a>
+ *             </code>, you can then use <code>
+ *                <a>DescribeTypeRegistration</a>
+ *             </code> to
+ *          monitor the progress of that registration request.</p>
+ *          <p>Once the registration request has completed, use <code>
+ *                <a>DescribeType</a>
+ *             </code> to return detailed information about an extension.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeTypeRegistrationCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeTypeRegistrationCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeTypeRegistrationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTypeRegistrationCommandInput} for command's `input` shape.
+ * @see {@link DescribeTypeRegistrationCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeTypeRegistrationCommand extends $Command<DescribeTypeRegistrationCommandInput, DescribeTypeRegistrationCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeTypeRegistrationCommandInput;
+    constructor(input: DescribeTypeRegistrationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTypeRegistrationCommandInput, DescribeTypeRegistrationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DetectStackDriftCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { DetectStackDriftInput, DetectStackDriftOutput } from "../models/models_0";
+export interface DetectStackDriftCommandInput extends DetectStackDriftInput {
+}
+export interface DetectStackDriftCommandOutput extends DetectStackDriftOutput, __MetadataBearer {
+}
+/**
+ * <p>Detects whether a stack's actual configuration differs, or has
+ *             <i>drifted</i>, from it's expected configuration, as defined in the stack
+ *          template and any values specified as template parameters. For each resource in the stack
+ *          that supports drift detection, CloudFormation compares the actual configuration of the resource with
+ *          its expected template configuration. Only resource properties explicitly defined in the
+ *          stack template are checked for drift. A stack is considered to have drifted if one or more
+ *          of its resources differ from their expected template configurations. For more information,
+ *          see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html">Detecting
+ *             Unregulated Configuration Changes to Stacks and Resources</a>.</p>
+ *          <p>Use <code>DetectStackDrift</code> to detect drift on all supported resources for a
+ *          given stack, or <a>DetectStackResourceDrift</a> to detect drift on individual
+ *          resources.</p>
+ *          <p>For a list of stack resources that currently support drift detection, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html">Resources that Support Drift Detection</a>.</p>
+ *          <p>
+ *             <code>DetectStackDrift</code> can take up to several minutes, depending on the number
+ *          of resources contained within the stack. Use <a>DescribeStackDriftDetectionStatus</a> to monitor the progress of a detect stack
+ *          drift operation. Once the drift detection operation has completed, use <a>DescribeStackResourceDrifts</a> to return drift information about the stack and
+ *          its resources.</p>
+ *          <p>When detecting drift on a stack, CloudFormation does not detect drift on any nested stacks
+ *          belonging to that stack. Perform <code>DetectStackDrift</code> directly on the nested stack
+ *          itself.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DetectStackDriftCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DetectStackDriftCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DetectStackDriftCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetectStackDriftCommandInput} for command's `input` shape.
+ * @see {@link DetectStackDriftCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetectStackDriftCommand extends $Command<DetectStackDriftCommandInput, DetectStackDriftCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DetectStackDriftCommandInput;
+    constructor(input: DetectStackDriftCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectStackDriftCommandInput, DetectStackDriftCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,46 @@
+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 { DetectStackResourceDriftInput, DetectStackResourceDriftOutput } from "../models/models_0";
+export interface DetectStackResourceDriftCommandInput extends DetectStackResourceDriftInput {
+}
+export interface DetectStackResourceDriftCommandOutput extends DetectStackResourceDriftOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns information about whether a resource's actual configuration differs, or has
+ *             <i>drifted</i>, from it's expected configuration, as defined in the stack
+ *          template and any values specified as template parameters. This information includes actual
+ *          and expected property values for resources in which CloudFormation detects drift. Only resource
+ *          properties explicitly defined in the stack template are checked for drift. For more
+ *          information about stack and resource drift, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift.html">Detecting
+ *             Unregulated Configuration Changes to Stacks and Resources</a>.</p>
+ *          <p>Use <code>DetectStackResourceDrift</code> to detect drift on individual resources, or
+ *             <a>DetectStackDrift</a> to detect drift on all resources in a given stack
+ *          that support drift detection.</p>
+ *          <p>Resources that do not currently support drift detection cannot be checked. For a list
+ *          of resources that support drift detection, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-drift-resource-list.html">Resources that Support Drift Detection</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DetectStackResourceDriftCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DetectStackResourceDriftCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DetectStackResourceDriftCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetectStackResourceDriftCommandInput} for command's `input` shape.
+ * @see {@link DetectStackResourceDriftCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetectStackResourceDriftCommand extends $Command<DetectStackResourceDriftCommandInput, DetectStackResourceDriftCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DetectStackResourceDriftCommandInput;
+    constructor(input: DetectStackResourceDriftCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectStackResourceDriftCommandInput, DetectStackResourceDriftCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,78 @@
+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 { DetectStackSetDriftInput, DetectStackSetDriftOutput } from "../models/models_0";
+export interface DetectStackSetDriftCommandInput extends DetectStackSetDriftInput {
+}
+export interface DetectStackSetDriftCommandOutput extends DetectStackSetDriftOutput, __MetadataBearer {
+}
+/**
+ * <p>Detect drift on a stack set. When CloudFormation performs drift detection on a
+ *          stack set, it performs drift detection on the stack associated with each stack instance in
+ *          the stack set. For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-drift.html">How CloudFormation Performs Drift Detection on a Stack Set</a>.</p>
+ *          <p>
+ *             <code>DetectStackSetDrift</code> returns the <code>OperationId</code> of the stack set
+ *          drift detection operation. Use this operation id with <code>
+ *                <a>DescribeStackSetOperation</a>
+ *             </code> to monitor the progress of the drift
+ *          detection operation. The drift detection operation may take some time, depending on the
+ *          number of stack instances included in the stack set, as well as the number of resources
+ *          included in each stack.</p>
+ *          <p>Once the operation has completed, use the following actions to return drift
+ *          information:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Use <code>
+ *                      <a>DescribeStackSet</a>
+ *                   </code> to return detailed information
+ *                about the stack set, including detailed information about the last
+ *                   <i>completed</i> drift operation performed on the stack set.
+ *                (Information about drift operations that are in progress is not included.)</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>
+ *                      <a>ListStackInstances</a>
+ *                   </code> to return a list of stack
+ *                instances belonging to the stack set, including the drift status and last drift time
+ *                checked of each instance.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>
+ *                      <a>DescribeStackInstance</a>
+ *                   </code> to return detailed
+ *                information about a specific stack instance, including its drift status and last
+ *                drift time checked.</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information on performing a drift detection operation on a stack set, see
+ *             <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-drift.html">Detecting Unmanaged
+ *             Changes in Stack Sets</a>. </p>
+ *          <p>You can only run a single drift detection operation on a given stack set at one time. </p>
+ *          <p>To stop a drift detection stack set operation, use <code>
+ *                <a>StopStackSetOperation</a>
+ *             </code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DetectStackSetDriftCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DetectStackSetDriftCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DetectStackSetDriftCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DetectStackSetDriftCommandInput} for command's `input` shape.
+ * @see {@link DetectStackSetDriftCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DetectStackSetDriftCommand extends $Command<DetectStackSetDriftCommandInput, DetectStackSetDriftCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DetectStackSetDriftCommandInput;
+    constructor(input: DetectStackSetDriftCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectStackSetDriftCommandInput, DetectStackSetDriftCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/EstimateTemplateCostCommand.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 { EstimateTemplateCostInput, EstimateTemplateCostOutput } from "../models/models_0";
+export interface EstimateTemplateCostCommandInput extends EstimateTemplateCostInput {
+}
+export interface EstimateTemplateCostCommandOutput extends EstimateTemplateCostOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the estimated monthly cost of a template. The return value is an Amazon Web Services Simple
+ *          Monthly Calculator URL with a query string that describes the resources required to run the
+ *          template.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, EstimateTemplateCostCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, EstimateTemplateCostCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new EstimateTemplateCostCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EstimateTemplateCostCommandInput} for command's `input` shape.
+ * @see {@link EstimateTemplateCostCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class EstimateTemplateCostCommand extends $Command<EstimateTemplateCostCommandInput, EstimateTemplateCostCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: EstimateTemplateCostCommandInput;
+    constructor(input: EstimateTemplateCostCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EstimateTemplateCostCommandInput, EstimateTemplateCostCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ExecuteChangeSetCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { ExecuteChangeSetInput, ExecuteChangeSetOutput } from "../models/models_0";
+export interface ExecuteChangeSetCommandInput extends ExecuteChangeSetInput {
+}
+export interface ExecuteChangeSetCommandOutput extends ExecuteChangeSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates a stack using the input information that was provided when the specified
+ *          change set was created. After the call successfully completes, CloudFormation starts
+ *          updating the stack. Use the <a>DescribeStacks</a> action to view the status of
+ *          the update.</p>
+ *          <p>When you execute a change set, CloudFormation deletes all other change sets
+ *          associated with the stack because they aren't valid for the updated stack.</p>
+ *          <p>If a stack policy is associated with the stack, CloudFormation enforces the
+ *          policy during the update. You can't specify a temporary stack policy that overrides the
+ *          current policy.</p>
+ *          <p>To create a change set for the entire stack hierachy, <code>IncludeNestedStacks</code>
+ *          must have been set to <code>True</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ExecuteChangeSetCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ExecuteChangeSetCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ExecuteChangeSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExecuteChangeSetCommandInput} for command's `input` shape.
+ * @see {@link ExecuteChangeSetCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ExecuteChangeSetCommand extends $Command<ExecuteChangeSetCommandInput, ExecuteChangeSetCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ExecuteChangeSetCommandInput;
+    constructor(input: ExecuteChangeSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExecuteChangeSetCommandInput, ExecuteChangeSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/GetTemplateCommand.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 { GetTemplateInput, GetTemplateOutput } from "../models/models_0";
+export interface GetTemplateCommandInput extends GetTemplateInput {
+}
+export interface GetTemplateCommandOutput extends GetTemplateOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the template body for a specified stack. You can get the template for running
+ *          or deleted stacks.</p>
+ *          <p>For deleted stacks, GetTemplate returns the template for up to 90 days after the
+ *          stack has been deleted.</p>
+ *          <note>
+ *             <p>If the template does not exist, a <code>ValidationError</code> is returned.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, GetTemplateCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, GetTemplateCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new GetTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTemplateCommandInput} for command's `input` shape.
+ * @see {@link GetTemplateCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTemplateCommand extends $Command<GetTemplateCommandInput, GetTemplateCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: GetTemplateCommandInput;
+    constructor(input: GetTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTemplateCommandInput, GetTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,43 @@
+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 { GetTemplateSummaryInput, GetTemplateSummaryOutput } from "../models/models_0";
+export interface GetTemplateSummaryCommandInput extends GetTemplateSummaryInput {
+}
+export interface GetTemplateSummaryCommandOutput extends GetTemplateSummaryOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a new or existing template. The
+ *             <code>GetTemplateSummary</code> action is useful for viewing parameter information, such
+ *          as default parameter values and parameter types, before you create or update a stack or
+ *          stack set.</p>
+ *          <p>You can use the <code>GetTemplateSummary</code> action when you submit a template, or
+ *          you can get template information for a stack set, or a running or deleted stack.</p>
+ *          <p>For deleted stacks, <code>GetTemplateSummary</code> returns the template information
+ *          for up to 90 days after the stack has been deleted. If the template does not exist, a
+ *             <code>ValidationError</code> is returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, GetTemplateSummaryCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, GetTemplateSummaryCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new GetTemplateSummaryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTemplateSummaryCommandInput} for command's `input` shape.
+ * @see {@link GetTemplateSummaryCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetTemplateSummaryCommand extends $Command<GetTemplateSummaryCommandInput, GetTemplateSummaryCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: GetTemplateSummaryCommandInput;
+    constructor(input: GetTemplateSummaryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTemplateSummaryCommandInput, GetTemplateSummaryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ImportStacksToStackSetCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { ImportStacksToStackSetInput, ImportStacksToStackSetOutput } from "../models/models_0";
+export interface ImportStacksToStackSetCommandInput extends ImportStacksToStackSetInput {
+}
+export interface ImportStacksToStackSetCommandOutput extends ImportStacksToStackSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Import existing stacks into a new stack sets. Use the stack import operation to import
+ *          up to 10 stacks into a new stack set in the same account as the source stack or in a
+ *          different administrator account and Region, by specifying the stack ID of the stack you
+ *          intend to import.</p>
+ *          <note>
+ *             <p>
+ *                <code>ImportStacksToStackSet</code> is only supported by self-managed permissions.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ImportStacksToStackSetCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ImportStacksToStackSetCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ImportStacksToStackSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportStacksToStackSetCommandInput} for command's `input` shape.
+ * @see {@link ImportStacksToStackSetCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ImportStacksToStackSetCommand extends $Command<ImportStacksToStackSetCommandInput, ImportStacksToStackSetCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ImportStacksToStackSetCommandInput;
+    constructor(input: ImportStacksToStackSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportStacksToStackSetCommandInput, ImportStacksToStackSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListChangeSetsCommand.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 { ListChangeSetsInput, ListChangeSetsOutput } from "../models/models_0";
+export interface ListChangeSetsCommandInput extends ListChangeSetsInput {
+}
+export interface ListChangeSetsCommandOutput extends ListChangeSetsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the ID and status of each active change set for a stack. For example,
+ *          CloudFormation lists change sets that are in the <code>CREATE_IN_PROGRESS</code> or
+ *             <code>CREATE_PENDING</code> state.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ListChangeSetsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListChangeSetsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListChangeSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListChangeSetsCommandInput} for command's `input` shape.
+ * @see {@link ListChangeSetsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListChangeSetsCommand extends $Command<ListChangeSetsCommandInput, ListChangeSetsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListChangeSetsCommandInput;
+    constructor(input: ListChangeSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListChangeSetsCommandInput, ListChangeSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}