@aws-sdk/client-codepipeline 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/PutJobFailureResultCommand.d.ts

@@ -1,36 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { PutJobFailureResultInput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutJobFailureResultCommandInput extends PutJobFailureResultInput {
-}
-export interface PutJobFailureResultCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Represents the failure of a job as returned to the pipeline by a job worker. Used
- *             for custom actions only.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, PutJobFailureResultCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, PutJobFailureResultCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new PutJobFailureResultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutJobFailureResultCommandInput} for command's `input` shape.
- * @see {@link PutJobFailureResultCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutJobFailureResultCommand extends $Command<PutJobFailureResultCommandInput, PutJobFailureResultCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: PutJobFailureResultCommandInput;
-    constructor(input: PutJobFailureResultCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutJobFailureResultCommandInput, PutJobFailureResultCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/PutJobSuccessResultCommand.d.ts

@@ -1,36 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { PutJobSuccessResultInput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutJobSuccessResultCommandInput extends PutJobSuccessResultInput {
-}
-export interface PutJobSuccessResultCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Represents the success of a job as returned to the pipeline by a job worker. Used
- *             for custom actions only.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, PutJobSuccessResultCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, PutJobSuccessResultCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new PutJobSuccessResultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutJobSuccessResultCommandInput} for command's `input` shape.
- * @see {@link PutJobSuccessResultCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutJobSuccessResultCommand extends $Command<PutJobSuccessResultCommandInput, PutJobSuccessResultCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: PutJobSuccessResultCommandInput;
-    constructor(input: PutJobSuccessResultCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutJobSuccessResultCommandInput, PutJobSuccessResultCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/PutThirdPartyJobFailureResultCommand.d.ts

@@ -1,36 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { PutThirdPartyJobFailureResultInput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutThirdPartyJobFailureResultCommandInput extends PutThirdPartyJobFailureResultInput {
-}
-export interface PutThirdPartyJobFailureResultCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Represents the failure of a third party job as returned to the pipeline by a job
- *             worker. Used for partner actions only.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, PutThirdPartyJobFailureResultCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, PutThirdPartyJobFailureResultCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new PutThirdPartyJobFailureResultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutThirdPartyJobFailureResultCommandInput} for command's `input` shape.
- * @see {@link PutThirdPartyJobFailureResultCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutThirdPartyJobFailureResultCommand extends $Command<PutThirdPartyJobFailureResultCommandInput, PutThirdPartyJobFailureResultCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: PutThirdPartyJobFailureResultCommandInput;
-    constructor(input: PutThirdPartyJobFailureResultCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutThirdPartyJobFailureResultCommandInput, PutThirdPartyJobFailureResultCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/PutThirdPartyJobSuccessResultCommand.d.ts

@@ -1,36 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { PutThirdPartyJobSuccessResultInput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutThirdPartyJobSuccessResultCommandInput extends PutThirdPartyJobSuccessResultInput {
-}
-export interface PutThirdPartyJobSuccessResultCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Represents the success of a third party job as returned to the pipeline by a job
- *             worker. Used for partner actions only.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, PutThirdPartyJobSuccessResultCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, PutThirdPartyJobSuccessResultCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new PutThirdPartyJobSuccessResultCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutThirdPartyJobSuccessResultCommandInput} for command's `input` shape.
- * @see {@link PutThirdPartyJobSuccessResultCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutThirdPartyJobSuccessResultCommand extends $Command<PutThirdPartyJobSuccessResultCommandInput, PutThirdPartyJobSuccessResultCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: PutThirdPartyJobSuccessResultCommandInput;
-    constructor(input: PutThirdPartyJobSuccessResultCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutThirdPartyJobSuccessResultCommandInput, PutThirdPartyJobSuccessResultCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/PutWebhookCommand.d.ts

@@ -1,41 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { PutWebhookInput, PutWebhookOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutWebhookCommandInput extends PutWebhookInput {
-}
-export interface PutWebhookCommandOutput extends PutWebhookOutput, __MetadataBearer {
-}
-/**
- * <p>Defines a webhook and returns a unique webhook URL generated by CodePipeline. This
- *             URL can be supplied to third party source hosting providers to call every time there's a
- *             code change. When CodePipeline receives a POST request on this URL, the pipeline defined
- *             in the webhook is started as long as the POST request satisfied the authentication and
- *             filtering requirements supplied when defining the webhook. RegisterWebhookWithThirdParty
- *             and DeregisterWebhookWithThirdParty APIs can be used to automatically configure
- *             supported third parties to call the generated webhook URL.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, PutWebhookCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, PutWebhookCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new PutWebhookCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutWebhookCommandInput} for command's `input` shape.
- * @see {@link PutWebhookCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutWebhookCommand extends $Command<PutWebhookCommandInput, PutWebhookCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: PutWebhookCommandInput;
-    constructor(input: PutWebhookCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutWebhookCommandInput, PutWebhookCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RetryStageExecutionCommand.d.ts

@@ -1,38 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { RetryStageExecutionInput, RetryStageExecutionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RetryStageExecutionCommandInput extends RetryStageExecutionInput {
-}
-export interface RetryStageExecutionCommandOutput extends RetryStageExecutionOutput, __MetadataBearer {
-}
-/**
- * <p>Resumes the pipeline execution by retrying the last failed actions in a stage. You
- *             can retry a stage immediately if any of the actions in the stage fail. When you retry,
- *             all actions that are still in progress continue working, and failed actions are
- *             triggered again.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, RetryStageExecutionCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, RetryStageExecutionCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new RetryStageExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RetryStageExecutionCommandInput} for command's `input` shape.
- * @see {@link RetryStageExecutionCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RetryStageExecutionCommand extends $Command<RetryStageExecutionCommandInput, RetryStageExecutionCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: RetryStageExecutionCommandInput;
-    constructor(input: RetryStageExecutionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RetryStageExecutionCommandInput, RetryStageExecutionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StartPipelineExecutionCommand.d.ts

@@ -1,36 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { StartPipelineExecutionInput, StartPipelineExecutionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartPipelineExecutionCommandInput extends StartPipelineExecutionInput {
-}
-export interface StartPipelineExecutionCommandOutput extends StartPipelineExecutionOutput, __MetadataBearer {
-}
-/**
- * <p>Starts the specified pipeline. Specifically, it begins processing the latest commit
- *             to the source location specified as part of the pipeline.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, StartPipelineExecutionCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, StartPipelineExecutionCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new StartPipelineExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartPipelineExecutionCommandInput} for command's `input` shape.
- * @see {@link StartPipelineExecutionCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartPipelineExecutionCommand extends $Command<StartPipelineExecutionCommandInput, StartPipelineExecutionCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: StartPipelineExecutionCommandInput;
-    constructor(input: StartPipelineExecutionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartPipelineExecutionCommandInput, StartPipelineExecutionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StopPipelineExecutionCommand.d.ts

@@ -1,40 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { StopPipelineExecutionInput, StopPipelineExecutionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopPipelineExecutionCommandInput extends StopPipelineExecutionInput {
-}
-export interface StopPipelineExecutionCommandOutput extends StopPipelineExecutionOutput, __MetadataBearer {
-}
-/**
- * <p>Stops the specified pipeline execution. You choose to either stop the pipeline
- *             execution by completing in-progress actions without starting subsequent actions, or by
- *             abandoning in-progress actions. While completing or abandoning in-progress actions, the
- *             pipeline execution is in a <code>Stopping</code> state. After all in-progress actions
- *             are completed or abandoned, the pipeline execution is in a <code>Stopped</code>
- *             state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, StopPipelineExecutionCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, StopPipelineExecutionCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new StopPipelineExecutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopPipelineExecutionCommandInput} for command's `input` shape.
- * @see {@link StopPipelineExecutionCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopPipelineExecutionCommand extends $Command<StopPipelineExecutionCommandInput, StopPipelineExecutionCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: StopPipelineExecutionCommandInput;
-    constructor(input: StopPipelineExecutionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopPipelineExecutionCommandInput, StopPipelineExecutionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/TagResourceCommand.d.ts

@@ -1,36 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { TagResourceInput, TagResourceOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TagResourceCommandInput extends TagResourceInput {
-}
-export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataBearer {
-}
-/**
- * <p>Adds to or modifies the tags of the given resource. Tags are metadata that can be used
- *             to manage a resource. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, TagResourceCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, TagResourceCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { UntagResourceInput, UntagResourceOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UntagResourceCommandInput extends UntagResourceInput {
-}
-export interface UntagResourceCommandOutput extends UntagResourceOutput, __MetadataBearer {
-}
-/**
- * <p>Removes tags from an AWS resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, UntagResourceCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, UntagResourceCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: UntagResourceCommandInput;
-    constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateActionTypeCommand.d.ts

@@ -1,38 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { UpdateActionTypeInput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateActionTypeCommandInput extends UpdateActionTypeInput {
-}
-export interface UpdateActionTypeCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Updates an action type that was created with any supported integration model, where
- *             the action type is to be used by customers of the action type provider. Use a JSON file
- *             with the action definition and <code>UpdateActionType</code> to provide the full
- *             structure.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, UpdateActionTypeCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, UpdateActionTypeCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new UpdateActionTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateActionTypeCommandInput} for command's `input` shape.
- * @see {@link UpdateActionTypeCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateActionTypeCommand extends $Command<UpdateActionTypeCommandInput, UpdateActionTypeCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: UpdateActionTypeCommandInput;
-    constructor(input: UpdateActionTypeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateActionTypeCommandInput, UpdateActionTypeCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdatePipelineCommand.d.ts

@@ -1,38 +0,0 @@
-import { CodePipelineClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodePipelineClient";
-import { UpdatePipelineInput, UpdatePipelineOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdatePipelineCommandInput extends UpdatePipelineInput {
-}
-export interface UpdatePipelineCommandOutput extends UpdatePipelineOutput, __MetadataBearer {
-}
-/**
- * <p>Updates a specified pipeline with edits or changes to its structure. Use a JSON
- *             file with the pipeline structure and <code>UpdatePipeline</code> to provide the full
- *             structure of the pipeline. Updating the pipeline increases the version number of the
- *             pipeline by 1.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CodePipelineClient, UpdatePipelineCommand } from "@aws-sdk/client-codepipeline"; // ES Modules import
- * // const { CodePipelineClient, UpdatePipelineCommand } = require("@aws-sdk/client-codepipeline"); // CommonJS import
- * const client = new CodePipelineClient(config);
- * const command = new UpdatePipelineCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdatePipelineCommandInput} for command's `input` shape.
- * @see {@link UpdatePipelineCommandOutput} for command's `response` shape.
- * @see {@link CodePipelineClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdatePipelineCommand extends $Command<UpdatePipelineCommandInput, UpdatePipelineCommandOutput, CodePipelineClientResolvedConfig> {
-    readonly input: UpdatePipelineCommandInput;
-    constructor(input: UpdatePipelineCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodePipelineClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePipelineCommandInput, UpdatePipelineCommandOutput>;
-    private serialize;
-    private deserialize;
-}