@aws-sdk/client-cloudformation 3.33.0 → 3.36.1

package/dist-types/commands/DeleteChangeSetCommand.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 { DeleteChangeSetInput, DeleteChangeSetOutput } from "../models/models_0";
+export interface DeleteChangeSetCommandInput extends DeleteChangeSetInput {
+}
+export interface DeleteChangeSetCommandOutput extends DeleteChangeSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes the specified change set. Deleting change sets ensures that no one executes
+ *          the wrong change set.</p>
+ *          <p>If the call successfully completes, CloudFormation successfully deleted the
+ *          change set.</p>
+ *          <p>If <code>IncludeNestedStacks</code> specifies <code>True</code> during the creation of
+ *          the nested change set, then <code>DeleteChangeSet</code> will delete all change sets that
+ *          belong to the stacks hierarchy and will also delete all change sets for nested stacks with
+ *          the status of <code>REVIEW_IN_PROGRESS</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DeleteChangeSetCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DeleteChangeSetCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DeleteChangeSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteChangeSetCommandInput} for command's `input` shape.
+ * @see {@link DeleteChangeSetCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteChangeSetCommand extends $Command<DeleteChangeSetCommandInput, DeleteChangeSetCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DeleteChangeSetCommandInput;
+    constructor(input: DeleteChangeSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteChangeSetCommandInput, DeleteChangeSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteStackCommand.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 { DeleteStackInput } from "../models/models_0";
+export interface DeleteStackCommandInput extends DeleteStackInput {
+}
+export interface DeleteStackCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a specified stack. Once the call completes successfully, stack deletion
+ *          starts. Deleted stacks do not show up in the <a>DescribeStacks</a> API if the
+ *          deletion has been completed successfully.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DeleteStackCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DeleteStackCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DeleteStackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteStackCommandInput} for command's `input` shape.
+ * @see {@link DeleteStackCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteStackCommand extends $Command<DeleteStackCommandInput, DeleteStackCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DeleteStackCommandInput;
+    constructor(input: DeleteStackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStackCommandInput, DeleteStackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/DeleteStackSetCommand.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 { DeleteStackSetInput, DeleteStackSetOutput } from "../models/models_0";
+export interface DeleteStackSetCommandInput extends DeleteStackSetInput {
+}
+export interface DeleteStackSetCommandOutput extends DeleteStackSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Deletes a stack set. Before you can delete a stack set, all of its member stack
+ *          instances must be deleted. For more information about how to do this, see <a>DeleteStackInstances</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DeleteStackSetCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DeleteStackSetCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DeleteStackSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteStackSetCommandInput} for command's `input` shape.
+ * @see {@link DeleteStackSetCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteStackSetCommand extends $Command<DeleteStackSetCommandInput, DeleteStackSetCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DeleteStackSetCommandInput;
+    constructor(input: DeleteStackSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStackSetCommandInput, DeleteStackSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeregisterTypeCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { DeregisterTypeInput, DeregisterTypeOutput } from "../models/models_0";
+export interface DeregisterTypeCommandInput extends DeregisterTypeInput {
+}
+export interface DeregisterTypeCommandOutput extends DeregisterTypeOutput, __MetadataBearer {
+}
+/**
+ * <p>Marks an extension or extension version as <code>DEPRECATED</code> in the CloudFormation registry, removing it from active use. Deprecated extensions or
+ *          extension versions cannot be used in CloudFormation operations.</p>
+ *          <p>To deregister an entire extension, you must individually deregister all active versions
+ *          of that extension. If an extension has only a single active version, deregistering that
+ *          version results in the extension itself being deregistered and marked as deprecated in the
+ *          registry. </p>
+ *          <p>You cannot deregister the default version of an extension if there are other active
+ *          version of that extension. If you do deregister the default version of an extension, the
+ *          textensionype itself is deregistered as well and marked as deprecated. </p>
+ *          <p>To view the deprecation status of an extension or extension version, use <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html">DescribeType</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DeregisterTypeCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DeregisterTypeCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DeregisterTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeregisterTypeCommandInput} for command's `input` shape.
+ * @see {@link DeregisterTypeCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeregisterTypeCommand extends $Command<DeregisterTypeCommandInput, DeregisterTypeCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DeregisterTypeCommandInput;
+    constructor(input: DeregisterTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterTypeCommandInput, DeregisterTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeAccountLimitsCommand.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 { DescribeAccountLimitsInput, DescribeAccountLimitsOutput } from "../models/models_0";
+export interface DescribeAccountLimitsCommandInput extends DescribeAccountLimitsInput {
+}
+export interface DescribeAccountLimitsCommandOutput extends DescribeAccountLimitsOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves your account's CloudFormation limits, such as the maximum number of
+ *          stacks that you can create in your account. For more information about account limits, see
+ *             <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html">CloudFormation
+ *             Limits</a> in the <i>CloudFormation User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeAccountLimitsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeAccountLimitsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeAccountLimitsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeAccountLimitsCommandInput} for command's `input` shape.
+ * @see {@link DescribeAccountLimitsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeAccountLimitsCommand extends $Command<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeAccountLimitsCommandInput;
+    constructor(input: DescribeAccountLimitsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountLimitsCommandInput, DescribeAccountLimitsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeChangeSetCommand.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 { DescribeChangeSetInput, DescribeChangeSetOutput } from "../models/models_0";
+export interface DescribeChangeSetCommandInput extends DescribeChangeSetInput {
+}
+export interface DescribeChangeSetCommandOutput extends DescribeChangeSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the inputs for the change set and a list of changes that CloudFormation
+ *          will make if you execute the change set. For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html">Updating Stacks Using Change Sets</a> in the CloudFormation User
+ *          Guide.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeChangeSetCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeChangeSetCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeChangeSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeChangeSetCommandInput} for command's `input` shape.
+ * @see {@link DescribeChangeSetCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeChangeSetCommand extends $Command<DescribeChangeSetCommandInput, DescribeChangeSetCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeChangeSetCommandInput;
+    constructor(input: DescribeChangeSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeChangeSetCommandInput, DescribeChangeSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,53 @@
+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 { DescribePublisherInput, DescribePublisherOutput } from "../models/models_0";
+export interface DescribePublisherCommandInput extends DescribePublisherInput {
+}
+export interface DescribePublisherCommandOutput extends DescribePublisherOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a CloudFormation extension publisher.</p>
+ *          <p>If you do not supply a <code>PublisherId</code>, and you have registered as an extension
+ *          publisher, <code>DescribePublisher</code> returns information about your own publisher
+ *          account. </p>
+ *          <p>For more information on registering as a publisher, see:</p>
+ *          <ul>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterPublisher.html">RegisterPublisher</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html">Publishing
+ *                   extensions to make them available for public use</a> in the
+ *                   <i>CloudFormation CLI User Guide</i>
+ *                </p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribePublisherCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribePublisherCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribePublisherCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribePublisherCommandInput} for command's `input` shape.
+ * @see {@link DescribePublisherCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribePublisherCommand extends $Command<DescribePublisherCommandInput, DescribePublisherCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribePublisherCommandInput;
+    constructor(input: DescribePublisherCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePublisherCommandInput, DescribePublisherCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeStackDriftDetectionStatusCommand.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 { DescribeStackDriftDetectionStatusInput, DescribeStackDriftDetectionStatusOutput } from "../models/models_0";
+export interface DescribeStackDriftDetectionStatusCommandInput extends DescribeStackDriftDetectionStatusInput {
+}
+export interface DescribeStackDriftDetectionStatusCommandOutput extends DescribeStackDriftDetectionStatusOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a stack drift detection operation. A stack drift detection
+ *          operation 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. A stack is considered to have
+ *          drifted if one or more of its resources have drifted. For more information on 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 <a>DetectStackDrift</a> to initiate a stack drift detection operation.
+ *             <code>DetectStackDrift</code> returns a <code>StackDriftDetectionId</code> you can use
+ *          to monitor the progress of the operation using
+ *             <code>DescribeStackDriftDetectionStatus</code>. Once the drift detection operation has
+ *          completed, use <a>DescribeStackResourceDrifts</a> to return drift information
+ *          about the stack and its resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStackDriftDetectionStatusCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStackDriftDetectionStatusCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStackDriftDetectionStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStackDriftDetectionStatusCommandInput} for command's `input` shape.
+ * @see {@link DescribeStackDriftDetectionStatusCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStackDriftDetectionStatusCommand extends $Command<DescribeStackDriftDetectionStatusCommandInput, DescribeStackDriftDetectionStatusCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStackDriftDetectionStatusCommandInput;
+    constructor(input: DescribeStackDriftDetectionStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStackDriftDetectionStatusCommandInput, DescribeStackDriftDetectionStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeStackEventsCommand.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 { DescribeStackEventsInput, DescribeStackEventsOutput } from "../models/models_0";
+export interface DescribeStackEventsCommandInput extends DescribeStackEventsInput {
+}
+export interface DescribeStackEventsCommandOutput extends DescribeStackEventsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns all stack related events for a specified stack in reverse chronological
+ *          order. For more information about a stack's event history, go to <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/concept-stack.html">Stacks</a> in the CloudFormation User Guide.</p>
+ *          <note>
+ *             <p>You can list events for stacks that have failed to create or have been deleted by
+ *             specifying the unique stack identifier (stack ID).</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStackEventsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStackEventsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStackEventsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStackEventsCommandInput} for command's `input` shape.
+ * @see {@link DescribeStackEventsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStackEventsCommand extends $Command<DescribeStackEventsCommandInput, DescribeStackEventsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStackEventsCommandInput;
+    constructor(input: DescribeStackEventsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStackEventsCommandInput, DescribeStackEventsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeStackInstanceCommand.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 { DescribeStackInstanceInput, DescribeStackInstanceOutput } from "../models/models_0";
+export interface DescribeStackInstanceCommandInput extends DescribeStackInstanceInput {
+}
+export interface DescribeStackInstanceCommandOutput extends DescribeStackInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the stack instance that's associated with the specified stack set, Amazon Web Services account, and Region.</p>
+ *          <p>For a list of stack instances that are associated with a specific stack set, use
+ *             <a>ListStackInstances</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStackInstanceCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStackInstanceCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStackInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStackInstanceCommandInput} for command's `input` shape.
+ * @see {@link DescribeStackInstanceCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStackInstanceCommand extends $Command<DescribeStackInstanceCommandInput, DescribeStackInstanceCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStackInstanceCommandInput;
+    constructor(input: DescribeStackInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStackInstanceCommandInput, DescribeStackInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeStackResourceCommand.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 { DescribeStackResourceInput, DescribeStackResourceOutput } from "../models/models_0";
+export interface DescribeStackResourceCommandInput extends DescribeStackResourceInput {
+}
+export interface DescribeStackResourceCommandOutput extends DescribeStackResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a description of the specified resource in the specified stack.</p>
+ *          <p>For deleted stacks, DescribeStackResource returns resource information for up to 90
+ *          days after the stack has been deleted.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStackResourceCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStackResourceCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStackResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStackResourceCommandInput} for command's `input` shape.
+ * @see {@link DescribeStackResourceCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStackResourceCommand extends $Command<DescribeStackResourceCommandInput, DescribeStackResourceCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStackResourceCommandInput;
+    constructor(input: DescribeStackResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStackResourceCommandInput, DescribeStackResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeStackResourceDriftsCommand.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 { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { DescribeStackResourceDriftsInput, DescribeStackResourceDriftsOutput } from "../models/models_0";
+export interface DescribeStackResourceDriftsCommandInput extends DescribeStackResourceDriftsInput {
+}
+export interface DescribeStackResourceDriftsCommandOutput extends DescribeStackResourceDriftsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns drift information for the resources that have been checked for drift in the
+ *          specified stack. This includes actual and expected configuration values for resources where
+ *          CloudFormation detects configuration drift.</p>
+ *          <p>For a given stack, there will be one <code>StackResourceDrift</code> for each stack
+ *          resource that has been checked for drift. Resources that haven't yet been checked for drift
+ *          are not included. Resources that do not currently support drift detection are not checked,
+ *          and so not included. 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>
+ *          <p>Use <a>DetectStackResourceDrift</a> to detect drift on individual
+ *          resources, or <a>DetectStackDrift</a> to detect drift on all supported resources
+ *          for a given stack.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStackResourceDriftsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStackResourceDriftsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStackResourceDriftsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStackResourceDriftsCommandInput} for command's `input` shape.
+ * @see {@link DescribeStackResourceDriftsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStackResourceDriftsCommand extends $Command<DescribeStackResourceDriftsCommandInput, DescribeStackResourceDriftsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStackResourceDriftsCommandInput;
+    constructor(input: DescribeStackResourceDriftsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStackResourceDriftsCommandInput, DescribeStackResourceDriftsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,54 @@
+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 { DescribeStackResourcesInput, DescribeStackResourcesOutput } from "../models/models_0";
+export interface DescribeStackResourcesCommandInput extends DescribeStackResourcesInput {
+}
+export interface DescribeStackResourcesCommandOutput extends DescribeStackResourcesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns Amazon Web Services resource descriptions for running and deleted stacks. If
+ *             <code>StackName</code> is specified, all the associated resources that are part of the
+ *          stack are returned. If <code>PhysicalResourceId</code> is specified, the associated
+ *          resources of the stack that the resource belongs to are returned.</p>
+ *          <note>
+ *             <p>Only the first 100 resources will be returned. If your stack has more resources
+ *             than this, you should use <code>ListStackResources</code> instead.</p>
+ *          </note>
+ *          <p>For deleted stacks, <code>DescribeStackResources</code> returns resource information
+ *          for up to 90 days after the stack has been deleted.</p>
+ *          <p>You must specify either <code>StackName</code> or <code>PhysicalResourceId</code>,
+ *          but not both. In addition, you can specify <code>LogicalResourceId</code> to filter the
+ *          returned result. For more information about resources, the <code>LogicalResourceId</code>
+ *          and <code>PhysicalResourceId</code>, go to the <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/">CloudFormation User
+ *          Guide</a>.</p>
+ *          <note>
+ *             <p>A <code>ValidationError</code> is returned if you specify both
+ *                <code>StackName</code> and <code>PhysicalResourceId</code> in the same
+ *             request.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, DescribeStackResourcesCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, DescribeStackResourcesCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new DescribeStackResourcesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeStackResourcesCommandInput} for command's `input` shape.
+ * @see {@link DescribeStackResourcesCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeStackResourcesCommand extends $Command<DescribeStackResourcesCommandInput, DescribeStackResourcesCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: DescribeStackResourcesCommandInput;
+    constructor(input: DescribeStackResourcesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeStackResourcesCommandInput, DescribeStackResourcesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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