@aws-sdk/client-cloudformation 3.33.0 → 3.36.1

package/dist-types/commands/ListExportsCommand.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 { ListExportsInput, ListExportsOutput } from "../models/models_0";
+export interface ListExportsCommandInput extends ListExportsInput {
+}
+export interface ListExportsCommandOutput extends ListExportsOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists all exported output values in the account and Region in which you call this
+ *          action. Use this action to see the exported output values that you can import into other
+ *          stacks. To import values, use the <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html">
+ *                <code>Fn::ImportValue</code>
+ *             </a> function.</p>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-stack-exports.html">
+ *             CloudFormation Export Stack Output Values</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ListExportsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListExportsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListExportsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListExportsCommandInput} for command's `input` shape.
+ * @see {@link ListExportsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListExportsCommand extends $Command<ListExportsCommandInput, ListExportsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListExportsCommandInput;
+    constructor(input: ListExportsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListExportsCommandInput, ListExportsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListImportsCommand.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 { ListImportsInput, ListImportsOutput } from "../models/models_0";
+export interface ListImportsCommandInput extends ListImportsInput {
+}
+export interface ListImportsCommandOutput extends ListImportsOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists all stacks that are importing an exported output value. To modify or remove an
+ *          exported output value, first use this action to see which stacks are using it. To see the
+ *          exported output values in your account, see <a>ListExports</a>.</p>
+ *          <p>For more information about importing an exported output value, see the <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html">
+ *                <code>Fn::ImportValue</code>
+ *             </a> function.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ListImportsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListImportsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListImportsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListImportsCommandInput} for command's `input` shape.
+ * @see {@link ListImportsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListImportsCommand extends $Command<ListImportsCommandInput, ListImportsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListImportsCommandInput;
+    constructor(input: ListImportsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListImportsCommandInput, ListImportsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/ListStackResourcesCommand.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 { ListStackResourcesInput, ListStackResourcesOutput } from "../models/models_0";
+export interface ListStackResourcesCommandInput extends ListStackResourcesInput {
+}
+export interface ListStackResourcesCommandOutput extends ListStackResourcesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns descriptions of all resources of the specified stack.</p>
+ *          <p>For deleted stacks, ListStackResources 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, ListStackResourcesCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListStackResourcesCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListStackResourcesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListStackResourcesCommandInput} for command's `input` shape.
+ * @see {@link ListStackResourcesCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListStackResourcesCommand extends $Command<ListStackResourcesCommandInput, ListStackResourcesCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListStackResourcesCommandInput;
+    constructor(input: ListStackResourcesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStackResourcesCommandInput, ListStackResourcesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/ListStackSetsCommand.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 { ListStackSetsInput, ListStackSetsOutput } from "../models/models_0";
+export interface ListStackSetsCommandInput extends ListStackSetsInput {
+}
+export interface ListStackSetsCommandOutput extends ListStackSetsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns summary information about stack sets that are associated with the
+ *          user.</p>
+ *          <ul>
+ *             <li>
+ *                <p>[Self-managed permissions] If you set the <code>CallAs</code> parameter to
+ *                   <code>SELF</code> while signed in to your Amazon Web Services account,
+ *                   <code>ListStackSets</code> returns all self-managed stack sets in your Amazon Web Services account.</p>
+ *             </li>
+ *             <li>
+ *                <p>[Service-managed permissions] If you set the <code>CallAs</code> parameter to
+ *                   <code>SELF</code> while signed in to the organization's management account,
+ *                   <code>ListStackSets</code> returns all stack sets in the management
+ *                account.</p>
+ *             </li>
+ *             <li>
+ *                <p>[Service-managed permissions] If you set the <code>CallAs</code> parameter to
+ *                   <code>DELEGATED_ADMIN</code> while signed in to your member account,
+ *                   <code>ListStackSets</code> returns all stack sets with service-managed permissions
+ *                in the management account.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ListStackSetsCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListStackSetsCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListStackSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListStackSetsCommandInput} for command's `input` shape.
+ * @see {@link ListStackSetsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListStackSetsCommand extends $Command<ListStackSetsCommandInput, ListStackSetsCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListStackSetsCommandInput;
+    constructor(input: ListStackSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStackSetsCommandInput, ListStackSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFormationClient";
+import { ListStacksInput, ListStacksOutput } from "../models/models_0";
+export interface ListStacksCommandInput extends ListStacksInput {
+}
+export interface ListStacksCommandOutput extends ListStacksOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the summary information for stacks whose status matches the specified
+ *          StackStatusFilter. Summary information for stacks that have been deleted is kept for 90
+ *          days after the stack is deleted. If no StackStatusFilter is specified, summary information
+ *          for all stacks is returned (including existing stacks and stacks that have been
+ *          deleted).</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ListStacksCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListStacksCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListStacksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListStacksCommandInput} for command's `input` shape.
+ * @see {@link ListStacksCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListStacksCommand extends $Command<ListStacksCommandInput, ListStacksCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListStacksCommandInput;
+    constructor(input: ListStacksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListStacksCommandInput, ListStacksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/commands/ListTypesCommand.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 { ListTypesInput, ListTypesOutput } from "../models/models_0";
+export interface ListTypesCommandInput extends ListTypesInput {
+}
+export interface ListTypesCommandOutput extends ListTypesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns summary information about extension that have been registered with CloudFormation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, ListTypesCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, ListTypesCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new ListTypesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTypesCommandInput} for command's `input` shape.
+ * @see {@link ListTypesCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTypesCommand extends $Command<ListTypesCommandInput, ListTypesCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: ListTypesCommandInput;
+    constructor(input: ListTypesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTypesCommandInput, ListTypesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PublishTypeCommand.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 { PublishTypeInput, PublishTypeOutput } from "../models/models_0";
+export interface PublishTypeCommandInput extends PublishTypeInput {
+}
+export interface PublishTypeCommandOutput extends PublishTypeOutput, __MetadataBearer {
+}
+/**
+ * <p>Publishes the specified extension to the CloudFormation registry as a public extension
+ *          in this region. Public extensions are available for use by all CloudFormation users. For
+ *          more information on publishing extensions, see <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>
+ *          <p>To publish an extension, you must be registered as a publisher with CloudFormation. For
+ *          more information, see <a href="https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterPublisher.html">RegisterPublisher</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, PublishTypeCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, PublishTypeCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new PublishTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PublishTypeCommandInput} for command's `input` shape.
+ * @see {@link PublishTypeCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PublishTypeCommand extends $Command<PublishTypeCommandInput, PublishTypeCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: PublishTypeCommandInput;
+    constructor(input: PublishTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PublishTypeCommandInput, PublishTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RecordHandlerProgressCommand.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 { RecordHandlerProgressInput, RecordHandlerProgressOutput } from "../models/models_0";
+export interface RecordHandlerProgressCommandInput extends RecordHandlerProgressInput {
+}
+export interface RecordHandlerProgressCommandOutput extends RecordHandlerProgressOutput, __MetadataBearer {
+}
+/**
+ * <p>Reports progress of a resource handler to CloudFormation.</p>
+ *          <p>Reserved for use by the <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/what-is-cloudformation-cli.html">CloudFormation CLI</a>. Do not use this API in your code.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, RecordHandlerProgressCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, RecordHandlerProgressCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new RecordHandlerProgressCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RecordHandlerProgressCommandInput} for command's `input` shape.
+ * @see {@link RecordHandlerProgressCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RecordHandlerProgressCommand extends $Command<RecordHandlerProgressCommandInput, RecordHandlerProgressCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: RecordHandlerProgressCommandInput;
+    constructor(input: RecordHandlerProgressCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RecordHandlerProgressCommandInput, RecordHandlerProgressCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterPublisherCommand.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 { RegisterPublisherInput, RegisterPublisherOutput } from "../models/models_0";
+export interface RegisterPublisherCommandInput extends RegisterPublisherInput {
+}
+export interface RegisterPublisherCommandOutput extends RegisterPublisherOutput, __MetadataBearer {
+}
+/**
+ * <p>Registers your account as a publisher of public extensions in the CloudFormation
+ *          registry. Public extensions are available for use by all CloudFormation users. This
+ *          publisher ID applies to your account in all Amazon Web Services Regions.</p>
+ *          <p>For information on requirements for registering as a public extension publisher, see
+ *             <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/publish-extension.html#publish-extension-prereqs">Registering your account to publish CloudFormation
+ *             extensions</a> in the <i>CloudFormation CLI User Guide</i>.</p>
+ *          <p></p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, RegisterPublisherCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, RegisterPublisherCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new RegisterPublisherCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterPublisherCommandInput} for command's `input` shape.
+ * @see {@link RegisterPublisherCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterPublisherCommand extends $Command<RegisterPublisherCommandInput, RegisterPublisherCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: RegisterPublisherCommandInput;
+    constructor(input: RegisterPublisherCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterPublisherCommandInput, RegisterPublisherCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,62 @@
+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 { RegisterTypeInput, RegisterTypeOutput } from "../models/models_0";
+export interface RegisterTypeCommandInput extends RegisterTypeInput {
+}
+export interface RegisterTypeCommandOutput extends RegisterTypeOutput, __MetadataBearer {
+}
+/**
+ * <p>Registers an extension with the CloudFormation service. Registering an
+ *          extension makes it available for use in CloudFormation templates in your Amazon Web Services account, and includes:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Validating the extension schema</p>
+ *             </li>
+ *             <li>
+ *                <p>Determining which handlers, if any, have been specified for the extension</p>
+ *             </li>
+ *             <li>
+ *                <p>Making the extension available for use in your account</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information on how to develop extensions and ready them for registeration, see
+ *             <a href="https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-types.html">Creating Resource
+ *             Providers</a> in the <i>CloudFormation CLI User
+ *          Guide</i>.</p>
+ *          <p>You can have a maximum of 50 resource extension versions registered at a time. This
+ *          maximum is per account and per region. Use <a href="AWSCloudFormation/latest/APIReference/API_DeregisterType.html">DeregisterType</a> to deregister specific extension versions if necessary.</p>
+ *          <p>Once you have initiated a registration request using <code>
+ *                <a>RegisterType</a>
+ *             </code>, you can use <code>
+ *                <a>DescribeTypeRegistration</a>
+ *             </code> to
+ *          monitor the progress of the registration request.</p>
+ *          <p>Once you have registered a private extension in your account and region, use <a href="AWSCloudFormation/latest/APIReference/API_SetTypeConfiguration.html">SetTypeConfiguration</a> to specify configuration properties for the extension. 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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFormationClient, RegisterTypeCommand } from "@aws-sdk/client-cloudformation"; // ES Modules import
+ * // const { CloudFormationClient, RegisterTypeCommand } = require("@aws-sdk/client-cloudformation"); // CommonJS import
+ * const client = new CloudFormationClient(config);
+ * const command = new RegisterTypeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterTypeCommandInput} for command's `input` shape.
+ * @see {@link RegisterTypeCommandOutput} for command's `response` shape.
+ * @see {@link CloudFormationClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RegisterTypeCommand extends $Command<RegisterTypeCommandInput, RegisterTypeCommandOutput, CloudFormationClientResolvedConfig> {
+    readonly input: RegisterTypeCommandInput;
+    constructor(input: RegisterTypeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterTypeCommandInput, RegisterTypeCommandOutput>;
+    private serialize;
+    private deserialize;
+}