@aws-sdk/client-codepipeline 3.34.0 → 3.37.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2230 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AcknowledgeJobInput {
+    
+    jobId: string | undefined;
+    
+    nonce: string | undefined;
+}
+export declare namespace AcknowledgeJobInput {
+    
+    const filterSensitiveLog: (obj: AcknowledgeJobInput) => any;
+}
+export declare enum JobStatus {
+    Created = "Created",
+    Dispatched = "Dispatched",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Queued = "Queued",
+    Succeeded = "Succeeded",
+    TimedOut = "TimedOut"
+}
+
+export interface AcknowledgeJobOutput {
+    
+    status?: JobStatus | string;
+}
+export declare namespace AcknowledgeJobOutput {
+    
+    const filterSensitiveLog: (obj: AcknowledgeJobOutput) => any;
+}
+
+export interface InvalidNonceException extends __SmithyException, $MetadataBearer {
+    name: "InvalidNonceException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidNonceException {
+    
+    const filterSensitiveLog: (obj: InvalidNonceException) => any;
+}
+
+export interface JobNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "JobNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace JobNotFoundException {
+    
+    const filterSensitiveLog: (obj: JobNotFoundException) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+
+export interface AcknowledgeThirdPartyJobInput {
+    
+    jobId: string | undefined;
+    
+    nonce: string | undefined;
+    
+    clientToken: string | undefined;
+}
+export declare namespace AcknowledgeThirdPartyJobInput {
+    
+    const filterSensitiveLog: (obj: AcknowledgeThirdPartyJobInput) => any;
+}
+
+export interface AcknowledgeThirdPartyJobOutput {
+    
+    status?: JobStatus | string;
+}
+export declare namespace AcknowledgeThirdPartyJobOutput {
+    
+    const filterSensitiveLog: (obj: AcknowledgeThirdPartyJobOutput) => any;
+}
+
+export interface InvalidClientTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidClientTokenException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidClientTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidClientTokenException) => any;
+}
+export declare enum ActionCategory {
+    Approval = "Approval",
+    Build = "Build",
+    Deploy = "Deploy",
+    Invoke = "Invoke",
+    Source = "Source",
+    Test = "Test"
+}
+
+export interface ActionConfiguration {
+    
+    configuration?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ActionConfiguration {
+    
+    const filterSensitiveLog: (obj: ActionConfiguration) => any;
+}
+export declare enum ActionConfigurationPropertyType {
+    Boolean = "Boolean",
+    Number = "Number",
+    String = "String"
+}
+
+export interface ActionConfigurationProperty {
+    
+    name: string | undefined;
+    
+    required: boolean | undefined;
+    
+    key: boolean | undefined;
+    
+    secret: boolean | undefined;
+    
+    queryable?: boolean;
+    
+    description?: string;
+    
+    type?: ActionConfigurationPropertyType | string;
+}
+export declare namespace ActionConfigurationProperty {
+    
+    const filterSensitiveLog: (obj: ActionConfigurationProperty) => any;
+}
+
+export interface ActionContext {
+    
+    name?: string;
+    
+    actionExecutionId?: string;
+}
+export declare namespace ActionContext {
+    
+    const filterSensitiveLog: (obj: ActionContext) => any;
+}
+export declare enum ActionOwner {
+    AWS = "AWS",
+    Custom = "Custom",
+    ThirdParty = "ThirdParty"
+}
+
+export interface ActionTypeId {
+    
+    category: ActionCategory | string | undefined;
+    
+    owner: ActionOwner | string | undefined;
+    
+    provider: string | undefined;
+    
+    version: string | undefined;
+}
+export declare namespace ActionTypeId {
+    
+    const filterSensitiveLog: (obj: ActionTypeId) => any;
+}
+
+export interface InputArtifact {
+    
+    name: string | undefined;
+}
+export declare namespace InputArtifact {
+    
+    const filterSensitiveLog: (obj: InputArtifact) => any;
+}
+
+export interface OutputArtifact {
+    
+    name: string | undefined;
+}
+export declare namespace OutputArtifact {
+    
+    const filterSensitiveLog: (obj: OutputArtifact) => any;
+}
+
+export interface ActionDeclaration {
+    
+    name: string | undefined;
+    
+    actionTypeId: ActionTypeId | undefined;
+    
+    runOrder?: number;
+    
+    configuration?: {
+        [key: string]: string;
+    };
+    
+    outputArtifacts?: OutputArtifact[];
+    
+    inputArtifacts?: InputArtifact[];
+    
+    roleArn?: string;
+    
+    region?: string;
+    
+    namespace?: string;
+}
+export declare namespace ActionDeclaration {
+    
+    const filterSensitiveLog: (obj: ActionDeclaration) => any;
+}
+
+export interface ErrorDetails {
+    
+    code?: string;
+    
+    message?: string;
+}
+export declare namespace ErrorDetails {
+    
+    const filterSensitiveLog: (obj: ErrorDetails) => any;
+}
+export declare enum ActionExecutionStatus {
+    Abandoned = "Abandoned",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Succeeded = "Succeeded"
+}
+
+export interface ActionExecution {
+    
+    actionExecutionId?: string;
+    
+    status?: ActionExecutionStatus | string;
+    
+    summary?: string;
+    
+    lastStatusChange?: Date;
+    
+    token?: string;
+    
+    lastUpdatedBy?: string;
+    
+    externalExecutionId?: string;
+    
+    externalExecutionUrl?: string;
+    
+    percentComplete?: number;
+    
+    errorDetails?: ErrorDetails;
+}
+export declare namespace ActionExecution {
+    
+    const filterSensitiveLog: (obj: ActionExecution) => any;
+}
+
+export interface S3Location {
+    
+    bucket?: string;
+    
+    key?: string;
+}
+export declare namespace S3Location {
+    
+    const filterSensitiveLog: (obj: S3Location) => any;
+}
+
+export interface ArtifactDetail {
+    
+    name?: string;
+    
+    s3location?: S3Location;
+}
+export declare namespace ArtifactDetail {
+    
+    const filterSensitiveLog: (obj: ArtifactDetail) => any;
+}
+
+export interface ActionExecutionInput {
+    
+    actionTypeId?: ActionTypeId;
+    
+    configuration?: {
+        [key: string]: string;
+    };
+    
+    resolvedConfiguration?: {
+        [key: string]: string;
+    };
+    
+    roleArn?: string;
+    
+    region?: string;
+    
+    inputArtifacts?: ArtifactDetail[];
+    
+    namespace?: string;
+}
+export declare namespace ActionExecutionInput {
+    
+    const filterSensitiveLog: (obj: ActionExecutionInput) => any;
+}
+
+export interface ActionExecutionResult {
+    
+    externalExecutionId?: string;
+    
+    externalExecutionSummary?: string;
+    
+    externalExecutionUrl?: string;
+}
+export declare namespace ActionExecutionResult {
+    
+    const filterSensitiveLog: (obj: ActionExecutionResult) => any;
+}
+
+export interface ActionExecutionOutput {
+    
+    outputArtifacts?: ArtifactDetail[];
+    
+    executionResult?: ActionExecutionResult;
+    
+    outputVariables?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ActionExecutionOutput {
+    
+    const filterSensitiveLog: (obj: ActionExecutionOutput) => any;
+}
+
+export interface ActionExecutionDetail {
+    
+    pipelineExecutionId?: string;
+    
+    actionExecutionId?: string;
+    
+    pipelineVersion?: number;
+    
+    stageName?: string;
+    
+    actionName?: string;
+    
+    startTime?: Date;
+    
+    lastUpdateTime?: Date;
+    
+    status?: ActionExecutionStatus | string;
+    
+    input?: ActionExecutionInput;
+    
+    output?: ActionExecutionOutput;
+}
+export declare namespace ActionExecutionDetail {
+    
+    const filterSensitiveLog: (obj: ActionExecutionDetail) => any;
+}
+
+export interface ActionExecutionFilter {
+    
+    pipelineExecutionId?: string;
+}
+export declare namespace ActionExecutionFilter {
+    
+    const filterSensitiveLog: (obj: ActionExecutionFilter) => any;
+}
+
+export interface ActionNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ActionNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ActionNotFoundException {
+    
+    const filterSensitiveLog: (obj: ActionNotFoundException) => any;
+}
+
+export interface ActionRevision {
+    
+    revisionId: string | undefined;
+    
+    revisionChangeId: string | undefined;
+    
+    created: Date | undefined;
+}
+export declare namespace ActionRevision {
+    
+    const filterSensitiveLog: (obj: ActionRevision) => any;
+}
+
+export interface ActionState {
+    
+    actionName?: string;
+    
+    currentRevision?: ActionRevision;
+    
+    latestExecution?: ActionExecution;
+    
+    entityUrl?: string;
+    
+    revisionUrl?: string;
+}
+export declare namespace ActionState {
+    
+    const filterSensitiveLog: (obj: ActionState) => any;
+}
+
+export interface ArtifactDetails {
+    
+    minimumCount: number | undefined;
+    
+    maximumCount: number | undefined;
+}
+export declare namespace ArtifactDetails {
+    
+    const filterSensitiveLog: (obj: ArtifactDetails) => any;
+}
+
+export interface ActionTypeSettings {
+    
+    thirdPartyConfigurationUrl?: string;
+    
+    entityUrlTemplate?: string;
+    
+    executionUrlTemplate?: string;
+    
+    revisionUrlTemplate?: string;
+}
+export declare namespace ActionTypeSettings {
+    
+    const filterSensitiveLog: (obj: ActionTypeSettings) => any;
+}
+
+export interface ActionType {
+    
+    id: ActionTypeId | undefined;
+    
+    settings?: ActionTypeSettings;
+    
+    actionConfigurationProperties?: ActionConfigurationProperty[];
+    
+    inputArtifactDetails: ArtifactDetails | undefined;
+    
+    outputArtifactDetails: ArtifactDetails | undefined;
+}
+export declare namespace ActionType {
+    
+    const filterSensitiveLog: (obj: ActionType) => any;
+}
+
+export interface ActionTypeArtifactDetails {
+    
+    minimumCount: number | undefined;
+    
+    maximumCount: number | undefined;
+}
+export declare namespace ActionTypeArtifactDetails {
+    
+    const filterSensitiveLog: (obj: ActionTypeArtifactDetails) => any;
+}
+
+export interface JobWorkerExecutorConfiguration {
+    
+    pollingAccounts?: string[];
+    
+    pollingServicePrincipals?: string[];
+}
+export declare namespace JobWorkerExecutorConfiguration {
+    
+    const filterSensitiveLog: (obj: JobWorkerExecutorConfiguration) => any;
+}
+
+export interface LambdaExecutorConfiguration {
+    
+    lambdaFunctionArn: string | undefined;
+}
+export declare namespace LambdaExecutorConfiguration {
+    
+    const filterSensitiveLog: (obj: LambdaExecutorConfiguration) => any;
+}
+
+export interface ExecutorConfiguration {
+    
+    lambdaExecutorConfiguration?: LambdaExecutorConfiguration;
+    
+    jobWorkerExecutorConfiguration?: JobWorkerExecutorConfiguration;
+}
+export declare namespace ExecutorConfiguration {
+    
+    const filterSensitiveLog: (obj: ExecutorConfiguration) => any;
+}
+export declare enum ExecutorType {
+    JobWorker = "JobWorker",
+    Lambda = "Lambda"
+}
+
+export interface ActionTypeExecutor {
+    
+    configuration: ExecutorConfiguration | undefined;
+    
+    type: ExecutorType | string | undefined;
+    
+    policyStatementsTemplate?: string;
+    
+    jobTimeout?: number;
+}
+export declare namespace ActionTypeExecutor {
+    
+    const filterSensitiveLog: (obj: ActionTypeExecutor) => any;
+}
+
+export interface ActionTypeIdentifier {
+    
+    category: ActionCategory | string | undefined;
+    
+    owner: string | undefined;
+    
+    provider: string | undefined;
+    
+    version: string | undefined;
+}
+export declare namespace ActionTypeIdentifier {
+    
+    const filterSensitiveLog: (obj: ActionTypeIdentifier) => any;
+}
+
+export interface ActionTypePermissions {
+    
+    allowedAccounts: string[] | undefined;
+}
+export declare namespace ActionTypePermissions {
+    
+    const filterSensitiveLog: (obj: ActionTypePermissions) => any;
+}
+
+export interface ActionTypeProperty {
+    
+    name: string | undefined;
+    
+    optional: boolean | undefined;
+    
+    key: boolean | undefined;
+    
+    noEcho: boolean | undefined;
+    
+    queryable?: boolean;
+    
+    description?: string;
+}
+export declare namespace ActionTypeProperty {
+    
+    const filterSensitiveLog: (obj: ActionTypeProperty) => any;
+}
+
+export interface ActionTypeUrls {
+    
+    configurationUrl?: string;
+    
+    entityUrlTemplate?: string;
+    
+    executionUrlTemplate?: string;
+    
+    revisionUrlTemplate?: string;
+}
+export declare namespace ActionTypeUrls {
+    
+    const filterSensitiveLog: (obj: ActionTypeUrls) => any;
+}
+
+export interface ActionTypeDeclaration {
+    
+    description?: string;
+    
+    executor: ActionTypeExecutor | undefined;
+    
+    id: ActionTypeIdentifier | undefined;
+    
+    inputArtifactDetails: ActionTypeArtifactDetails | undefined;
+    
+    outputArtifactDetails: ActionTypeArtifactDetails | undefined;
+    
+    permissions?: ActionTypePermissions;
+    
+    properties?: ActionTypeProperty[];
+    
+    urls?: ActionTypeUrls;
+}
+export declare namespace ActionTypeDeclaration {
+    
+    const filterSensitiveLog: (obj: ActionTypeDeclaration) => any;
+}
+
+export interface ActionTypeNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ActionTypeNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ActionTypeNotFoundException {
+    
+    const filterSensitiveLog: (obj: ActionTypeNotFoundException) => any;
+}
+
+export interface ApprovalAlreadyCompletedException extends __SmithyException, $MetadataBearer {
+    name: "ApprovalAlreadyCompletedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ApprovalAlreadyCompletedException {
+    
+    const filterSensitiveLog: (obj: ApprovalAlreadyCompletedException) => any;
+}
+export declare enum ApprovalStatus {
+    Approved = "Approved",
+    Rejected = "Rejected"
+}
+
+export interface ApprovalResult {
+    
+    summary: string | undefined;
+    
+    status: ApprovalStatus | string | undefined;
+}
+export declare namespace ApprovalResult {
+    
+    const filterSensitiveLog: (obj: ApprovalResult) => any;
+}
+
+export interface S3ArtifactLocation {
+    
+    bucketName: string | undefined;
+    
+    objectKey: string | undefined;
+}
+export declare namespace S3ArtifactLocation {
+    
+    const filterSensitiveLog: (obj: S3ArtifactLocation) => any;
+}
+export declare enum ArtifactLocationType {
+    S3 = "S3"
+}
+
+export interface ArtifactLocation {
+    
+    type?: ArtifactLocationType | string;
+    
+    s3Location?: S3ArtifactLocation;
+}
+export declare namespace ArtifactLocation {
+    
+    const filterSensitiveLog: (obj: ArtifactLocation) => any;
+}
+
+export interface Artifact {
+    
+    name?: string;
+    
+    revision?: string;
+    
+    location?: ArtifactLocation;
+}
+export declare namespace Artifact {
+    
+    const filterSensitiveLog: (obj: Artifact) => any;
+}
+
+export interface ArtifactRevision {
+    
+    name?: string;
+    
+    revisionId?: string;
+    
+    revisionChangeIdentifier?: string;
+    
+    revisionSummary?: string;
+    
+    created?: Date;
+    
+    revisionUrl?: string;
+}
+export declare namespace ArtifactRevision {
+    
+    const filterSensitiveLog: (obj: ArtifactRevision) => any;
+}
+export declare enum EncryptionKeyType {
+    KMS = "KMS"
+}
+
+export interface EncryptionKey {
+    
+    id: string | undefined;
+    
+    type: EncryptionKeyType | string | undefined;
+}
+export declare namespace EncryptionKey {
+    
+    const filterSensitiveLog: (obj: EncryptionKey) => any;
+}
+export declare enum ArtifactStoreType {
+    S3 = "S3"
+}
+
+export interface ArtifactStore {
+    
+    type: ArtifactStoreType | string | undefined;
+    
+    location: string | undefined;
+    
+    encryptionKey?: EncryptionKey;
+}
+export declare namespace ArtifactStore {
+    
+    const filterSensitiveLog: (obj: ArtifactStore) => any;
+}
+
+export interface AWSSessionCredentials {
+    
+    accessKeyId: string | undefined;
+    
+    secretAccessKey: string | undefined;
+    
+    sessionToken: string | undefined;
+}
+export declare namespace AWSSessionCredentials {
+    
+    const filterSensitiveLog: (obj: AWSSessionCredentials) => any;
+}
+export declare enum BlockerType {
+    Schedule = "Schedule"
+}
+
+export interface BlockerDeclaration {
+    
+    name: string | undefined;
+    
+    type: BlockerType | string | undefined;
+}
+export declare namespace BlockerDeclaration {
+    
+    const filterSensitiveLog: (obj: BlockerDeclaration) => any;
+}
+
+export interface ConcurrentModificationException extends __SmithyException, $MetadataBearer {
+    name: "ConcurrentModificationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConcurrentModificationException {
+    
+    const filterSensitiveLog: (obj: ConcurrentModificationException) => any;
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface CreateCustomActionTypeInput {
+    
+    category: ActionCategory | string | undefined;
+    
+    provider: string | undefined;
+    
+    version: string | undefined;
+    
+    settings?: ActionTypeSettings;
+    
+    configurationProperties?: ActionConfigurationProperty[];
+    
+    inputArtifactDetails: ArtifactDetails | undefined;
+    
+    outputArtifactDetails: ArtifactDetails | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateCustomActionTypeInput {
+    
+    const filterSensitiveLog: (obj: CreateCustomActionTypeInput) => any;
+}
+
+export interface CreateCustomActionTypeOutput {
+    
+    actionType: ActionType | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateCustomActionTypeOutput {
+    
+    const filterSensitiveLog: (obj: CreateCustomActionTypeOutput) => any;
+}
+
+export interface InvalidTagsException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidTagsException {
+    
+    const filterSensitiveLog: (obj: InvalidTagsException) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace TooManyTagsException {
+    
+    const filterSensitiveLog: (obj: TooManyTagsException) => any;
+}
+
+export interface StageDeclaration {
+    
+    name: string | undefined;
+    
+    blockers?: BlockerDeclaration[];
+    
+    actions: ActionDeclaration[] | undefined;
+}
+export declare namespace StageDeclaration {
+    
+    const filterSensitiveLog: (obj: StageDeclaration) => any;
+}
+
+export interface PipelineDeclaration {
+    
+    name: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    artifactStore?: ArtifactStore;
+    
+    artifactStores?: {
+        [key: string]: ArtifactStore;
+    };
+    
+    stages: StageDeclaration[] | undefined;
+    
+    version?: number;
+}
+export declare namespace PipelineDeclaration {
+    
+    const filterSensitiveLog: (obj: PipelineDeclaration) => any;
+}
+
+export interface CreatePipelineInput {
+    
+    pipeline: PipelineDeclaration | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreatePipelineInput {
+    
+    const filterSensitiveLog: (obj: CreatePipelineInput) => any;
+}
+
+export interface CreatePipelineOutput {
+    
+    pipeline?: PipelineDeclaration;
+    
+    tags?: Tag[];
+}
+export declare namespace CreatePipelineOutput {
+    
+    const filterSensitiveLog: (obj: CreatePipelineOutput) => any;
+}
+
+export interface InvalidActionDeclarationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidActionDeclarationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidActionDeclarationException {
+    
+    const filterSensitiveLog: (obj: InvalidActionDeclarationException) => any;
+}
+
+export interface InvalidBlockerDeclarationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidBlockerDeclarationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidBlockerDeclarationException {
+    
+    const filterSensitiveLog: (obj: InvalidBlockerDeclarationException) => any;
+}
+
+export interface InvalidStageDeclarationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidStageDeclarationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidStageDeclarationException {
+    
+    const filterSensitiveLog: (obj: InvalidStageDeclarationException) => any;
+}
+
+export interface InvalidStructureException extends __SmithyException, $MetadataBearer {
+    name: "InvalidStructureException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidStructureException {
+    
+    const filterSensitiveLog: (obj: InvalidStructureException) => any;
+}
+
+export interface PipelineNameInUseException extends __SmithyException, $MetadataBearer {
+    name: "PipelineNameInUseException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace PipelineNameInUseException {
+    
+    const filterSensitiveLog: (obj: PipelineNameInUseException) => any;
+}
+
+export interface DeleteCustomActionTypeInput {
+    
+    category: ActionCategory | string | undefined;
+    
+    provider: string | undefined;
+    
+    version: string | undefined;
+}
+export declare namespace DeleteCustomActionTypeInput {
+    
+    const filterSensitiveLog: (obj: DeleteCustomActionTypeInput) => any;
+}
+
+export interface DeletePipelineInput {
+    
+    name: string | undefined;
+}
+export declare namespace DeletePipelineInput {
+    
+    const filterSensitiveLog: (obj: DeletePipelineInput) => any;
+}
+export interface DeleteWebhookInput {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteWebhookInput {
+    
+    const filterSensitiveLog: (obj: DeleteWebhookInput) => any;
+}
+export interface DeleteWebhookOutput {
+}
+export declare namespace DeleteWebhookOutput {
+    
+    const filterSensitiveLog: (obj: DeleteWebhookOutput) => any;
+}
+export interface DeregisterWebhookWithThirdPartyInput {
+    
+    webhookName?: string;
+}
+export declare namespace DeregisterWebhookWithThirdPartyInput {
+    
+    const filterSensitiveLog: (obj: DeregisterWebhookWithThirdPartyInput) => any;
+}
+export interface DeregisterWebhookWithThirdPartyOutput {
+}
+export declare namespace DeregisterWebhookWithThirdPartyOutput {
+    
+    const filterSensitiveLog: (obj: DeregisterWebhookWithThirdPartyOutput) => any;
+}
+
+export interface WebhookNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "WebhookNotFoundException";
+    $fault: "client";
+}
+export declare namespace WebhookNotFoundException {
+    
+    const filterSensitiveLog: (obj: WebhookNotFoundException) => any;
+}
+export declare enum StageTransitionType {
+    Inbound = "Inbound",
+    Outbound = "Outbound"
+}
+
+export interface DisableStageTransitionInput {
+    
+    pipelineName: string | undefined;
+    
+    stageName: string | undefined;
+    
+    transitionType: StageTransitionType | string | undefined;
+    
+    reason: string | undefined;
+}
+export declare namespace DisableStageTransitionInput {
+    
+    const filterSensitiveLog: (obj: DisableStageTransitionInput) => any;
+}
+
+export interface PipelineNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "PipelineNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace PipelineNotFoundException {
+    
+    const filterSensitiveLog: (obj: PipelineNotFoundException) => any;
+}
+
+export interface StageNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "StageNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace StageNotFoundException {
+    
+    const filterSensitiveLog: (obj: StageNotFoundException) => any;
+}
+
+export interface EnableStageTransitionInput {
+    
+    pipelineName: string | undefined;
+    
+    stageName: string | undefined;
+    
+    transitionType: StageTransitionType | string | undefined;
+}
+export declare namespace EnableStageTransitionInput {
+    
+    const filterSensitiveLog: (obj: EnableStageTransitionInput) => any;
+}
+export interface GetActionTypeInput {
+    
+    category: ActionCategory | string | undefined;
+    
+    owner: string | undefined;
+    
+    provider: string | undefined;
+    
+    version: string | undefined;
+}
+export declare namespace GetActionTypeInput {
+    
+    const filterSensitiveLog: (obj: GetActionTypeInput) => any;
+}
+export interface GetActionTypeOutput {
+    
+    actionType?: ActionTypeDeclaration;
+}
+export declare namespace GetActionTypeOutput {
+    
+    const filterSensitiveLog: (obj: GetActionTypeOutput) => any;
+}
+
+export interface GetJobDetailsInput {
+    
+    jobId: string | undefined;
+}
+export declare namespace GetJobDetailsInput {
+    
+    const filterSensitiveLog: (obj: GetJobDetailsInput) => any;
+}
+
+export interface StageContext {
+    
+    name?: string;
+}
+export declare namespace StageContext {
+    
+    const filterSensitiveLog: (obj: StageContext) => any;
+}
+
+export interface PipelineContext {
+    
+    pipelineName?: string;
+    
+    stage?: StageContext;
+    
+    action?: ActionContext;
+    
+    pipelineArn?: string;
+    
+    pipelineExecutionId?: string;
+}
+export declare namespace PipelineContext {
+    
+    const filterSensitiveLog: (obj: PipelineContext) => any;
+}
+
+export interface JobData {
+    
+    actionTypeId?: ActionTypeId;
+    
+    actionConfiguration?: ActionConfiguration;
+    
+    pipelineContext?: PipelineContext;
+    
+    inputArtifacts?: Artifact[];
+    
+    outputArtifacts?: Artifact[];
+    
+    artifactCredentials?: AWSSessionCredentials;
+    
+    continuationToken?: string;
+    
+    encryptionKey?: EncryptionKey;
+}
+export declare namespace JobData {
+    
+    const filterSensitiveLog: (obj: JobData) => any;
+}
+
+export interface JobDetails {
+    
+    id?: string;
+    
+    data?: JobData;
+    
+    accountId?: string;
+}
+export declare namespace JobDetails {
+    
+    const filterSensitiveLog: (obj: JobDetails) => any;
+}
+
+export interface GetJobDetailsOutput {
+    
+    jobDetails?: JobDetails;
+}
+export declare namespace GetJobDetailsOutput {
+    
+    const filterSensitiveLog: (obj: GetJobDetailsOutput) => any;
+}
+
+export interface GetPipelineInput {
+    
+    name: string | undefined;
+    
+    version?: number;
+}
+export declare namespace GetPipelineInput {
+    
+    const filterSensitiveLog: (obj: GetPipelineInput) => any;
+}
+
+export interface PipelineMetadata {
+    
+    pipelineArn?: string;
+    
+    created?: Date;
+    
+    updated?: Date;
+}
+export declare namespace PipelineMetadata {
+    
+    const filterSensitiveLog: (obj: PipelineMetadata) => any;
+}
+
+export interface GetPipelineOutput {
+    
+    pipeline?: PipelineDeclaration;
+    
+    metadata?: PipelineMetadata;
+}
+export declare namespace GetPipelineOutput {
+    
+    const filterSensitiveLog: (obj: GetPipelineOutput) => any;
+}
+
+export interface PipelineVersionNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "PipelineVersionNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace PipelineVersionNotFoundException {
+    
+    const filterSensitiveLog: (obj: PipelineVersionNotFoundException) => any;
+}
+
+export interface GetPipelineExecutionInput {
+    
+    pipelineName: string | undefined;
+    
+    pipelineExecutionId: string | undefined;
+}
+export declare namespace GetPipelineExecutionInput {
+    
+    const filterSensitiveLog: (obj: GetPipelineExecutionInput) => any;
+}
+export declare enum PipelineExecutionStatus {
+    Cancelled = "Cancelled",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Stopped = "Stopped",
+    Stopping = "Stopping",
+    Succeeded = "Succeeded",
+    Superseded = "Superseded"
+}
+
+export interface PipelineExecution {
+    
+    pipelineName?: string;
+    
+    pipelineVersion?: number;
+    
+    pipelineExecutionId?: string;
+    
+    status?: PipelineExecutionStatus | string;
+    
+    statusSummary?: string;
+    
+    artifactRevisions?: ArtifactRevision[];
+}
+export declare namespace PipelineExecution {
+    
+    const filterSensitiveLog: (obj: PipelineExecution) => any;
+}
+
+export interface GetPipelineExecutionOutput {
+    
+    pipelineExecution?: PipelineExecution;
+}
+export declare namespace GetPipelineExecutionOutput {
+    
+    const filterSensitiveLog: (obj: GetPipelineExecutionOutput) => any;
+}
+
+export interface PipelineExecutionNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "PipelineExecutionNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace PipelineExecutionNotFoundException {
+    
+    const filterSensitiveLog: (obj: PipelineExecutionNotFoundException) => any;
+}
+
+export interface GetPipelineStateInput {
+    
+    name: string | undefined;
+}
+export declare namespace GetPipelineStateInput {
+    
+    const filterSensitiveLog: (obj: GetPipelineStateInput) => any;
+}
+export declare enum StageExecutionStatus {
+    Cancelled = "Cancelled",
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Stopped = "Stopped",
+    Stopping = "Stopping",
+    Succeeded = "Succeeded"
+}
+
+export interface StageExecution {
+    
+    pipelineExecutionId: string | undefined;
+    
+    status: StageExecutionStatus | string | undefined;
+}
+export declare namespace StageExecution {
+    
+    const filterSensitiveLog: (obj: StageExecution) => any;
+}
+
+export interface TransitionState {
+    
+    enabled?: boolean;
+    
+    lastChangedBy?: string;
+    
+    lastChangedAt?: Date;
+    
+    disabledReason?: string;
+}
+export declare namespace TransitionState {
+    
+    const filterSensitiveLog: (obj: TransitionState) => any;
+}
+
+export interface StageState {
+    
+    stageName?: string;
+    
+    inboundExecution?: StageExecution;
+    
+    inboundTransitionState?: TransitionState;
+    
+    actionStates?: ActionState[];
+    
+    latestExecution?: StageExecution;
+}
+export declare namespace StageState {
+    
+    const filterSensitiveLog: (obj: StageState) => any;
+}
+
+export interface GetPipelineStateOutput {
+    
+    pipelineName?: string;
+    
+    pipelineVersion?: number;
+    
+    stageStates?: StageState[];
+    
+    created?: Date;
+    
+    updated?: Date;
+}
+export declare namespace GetPipelineStateOutput {
+    
+    const filterSensitiveLog: (obj: GetPipelineStateOutput) => any;
+}
+
+export interface GetThirdPartyJobDetailsInput {
+    
+    jobId: string | undefined;
+    
+    clientToken: string | undefined;
+}
+export declare namespace GetThirdPartyJobDetailsInput {
+    
+    const filterSensitiveLog: (obj: GetThirdPartyJobDetailsInput) => any;
+}
+
+export interface ThirdPartyJobData {
+    
+    actionTypeId?: ActionTypeId;
+    
+    actionConfiguration?: ActionConfiguration;
+    
+    pipelineContext?: PipelineContext;
+    
+    inputArtifacts?: Artifact[];
+    
+    outputArtifacts?: Artifact[];
+    
+    artifactCredentials?: AWSSessionCredentials;
+    
+    continuationToken?: string;
+    
+    encryptionKey?: EncryptionKey;
+}
+export declare namespace ThirdPartyJobData {
+    
+    const filterSensitiveLog: (obj: ThirdPartyJobData) => any;
+}
+
+export interface ThirdPartyJobDetails {
+    
+    id?: string;
+    
+    data?: ThirdPartyJobData;
+    
+    nonce?: string;
+}
+export declare namespace ThirdPartyJobDetails {
+    
+    const filterSensitiveLog: (obj: ThirdPartyJobDetails) => any;
+}
+
+export interface GetThirdPartyJobDetailsOutput {
+    
+    jobDetails?: ThirdPartyJobDetails;
+}
+export declare namespace GetThirdPartyJobDetailsOutput {
+    
+    const filterSensitiveLog: (obj: GetThirdPartyJobDetailsOutput) => any;
+}
+
+export interface InvalidJobException extends __SmithyException, $MetadataBearer {
+    name: "InvalidJobException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidJobException {
+    
+    const filterSensitiveLog: (obj: InvalidJobException) => any;
+}
+
+export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidNextTokenException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidNextTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidNextTokenException) => any;
+}
+export interface ListActionExecutionsInput {
+    
+    pipelineName: string | undefined;
+    
+    filter?: ActionExecutionFilter;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListActionExecutionsInput {
+    
+    const filterSensitiveLog: (obj: ListActionExecutionsInput) => any;
+}
+export interface ListActionExecutionsOutput {
+    
+    actionExecutionDetails?: ActionExecutionDetail[];
+    
+    nextToken?: string;
+}
+export declare namespace ListActionExecutionsOutput {
+    
+    const filterSensitiveLog: (obj: ListActionExecutionsOutput) => any;
+}
+
+export interface ListActionTypesInput {
+    
+    actionOwnerFilter?: ActionOwner | string;
+    
+    nextToken?: string;
+    
+    regionFilter?: string;
+}
+export declare namespace ListActionTypesInput {
+    
+    const filterSensitiveLog: (obj: ListActionTypesInput) => any;
+}
+
+export interface ListActionTypesOutput {
+    
+    actionTypes: ActionType[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListActionTypesOutput {
+    
+    const filterSensitiveLog: (obj: ListActionTypesOutput) => any;
+}
+
+export interface ListPipelineExecutionsInput {
+    
+    pipelineName: string | undefined;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListPipelineExecutionsInput {
+    
+    const filterSensitiveLog: (obj: ListPipelineExecutionsInput) => any;
+}
+
+export interface SourceRevision {
+    
+    actionName: string | undefined;
+    
+    revisionId?: string;
+    
+    revisionSummary?: string;
+    
+    revisionUrl?: string;
+}
+export declare namespace SourceRevision {
+    
+    const filterSensitiveLog: (obj: SourceRevision) => any;
+}
+
+export interface StopExecutionTrigger {
+    
+    reason?: string;
+}
+export declare namespace StopExecutionTrigger {
+    
+    const filterSensitiveLog: (obj: StopExecutionTrigger) => any;
+}
+export declare enum TriggerType {
+    CloudWatchEvent = "CloudWatchEvent",
+    CreatePipeline = "CreatePipeline",
+    PollForSourceChanges = "PollForSourceChanges",
+    PutActionRevision = "PutActionRevision",
+    StartPipelineExecution = "StartPipelineExecution",
+    Webhook = "Webhook"
+}
+
+export interface ExecutionTrigger {
+    
+    triggerType?: TriggerType | string;
+    
+    triggerDetail?: string;
+}
+export declare namespace ExecutionTrigger {
+    
+    const filterSensitiveLog: (obj: ExecutionTrigger) => any;
+}
+
+export interface PipelineExecutionSummary {
+    
+    pipelineExecutionId?: string;
+    
+    status?: PipelineExecutionStatus | string;
+    
+    startTime?: Date;
+    
+    lastUpdateTime?: Date;
+    
+    sourceRevisions?: SourceRevision[];
+    
+    trigger?: ExecutionTrigger;
+    
+    stopTrigger?: StopExecutionTrigger;
+}
+export declare namespace PipelineExecutionSummary {
+    
+    const filterSensitiveLog: (obj: PipelineExecutionSummary) => any;
+}
+
+export interface ListPipelineExecutionsOutput {
+    
+    pipelineExecutionSummaries?: PipelineExecutionSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListPipelineExecutionsOutput {
+    
+    const filterSensitiveLog: (obj: ListPipelineExecutionsOutput) => any;
+}
+
+export interface ListPipelinesInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListPipelinesInput {
+    
+    const filterSensitiveLog: (obj: ListPipelinesInput) => any;
+}
+
+export interface PipelineSummary {
+    
+    name?: string;
+    
+    version?: number;
+    
+    created?: Date;
+    
+    updated?: Date;
+}
+export declare namespace PipelineSummary {
+    
+    const filterSensitiveLog: (obj: PipelineSummary) => any;
+}
+
+export interface ListPipelinesOutput {
+    
+    pipelines?: PipelineSummary[];
+    
+    nextToken?: string;
+}
+export declare namespace ListPipelinesOutput {
+    
+    const filterSensitiveLog: (obj: ListPipelinesOutput) => any;
+}
+
+export interface InvalidArnException extends __SmithyException, $MetadataBearer {
+    name: "InvalidArnException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidArnException {
+    
+    const filterSensitiveLog: (obj: InvalidArnException) => any;
+}
+export interface ListTagsForResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListTagsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceInput) => any;
+}
+export interface ListTagsForResourceOutput {
+    
+    tags?: Tag[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceOutput) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+export interface ListWebhooksInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListWebhooksInput {
+    
+    const filterSensitiveLog: (obj: ListWebhooksInput) => any;
+}
+export declare enum WebhookAuthenticationType {
+    GITHUB_HMAC = "GITHUB_HMAC",
+    IP = "IP",
+    UNAUTHENTICATED = "UNAUTHENTICATED"
+}
+
+export interface WebhookAuthConfiguration {
+    
+    AllowedIPRange?: string;
+    
+    SecretToken?: string;
+}
+export declare namespace WebhookAuthConfiguration {
+    
+    const filterSensitiveLog: (obj: WebhookAuthConfiguration) => any;
+}
+
+export interface WebhookFilterRule {
+    
+    jsonPath: string | undefined;
+    
+    matchEquals?: string;
+}
+export declare namespace WebhookFilterRule {
+    
+    const filterSensitiveLog: (obj: WebhookFilterRule) => any;
+}
+
+export interface WebhookDefinition {
+    
+    name: string | undefined;
+    
+    targetPipeline: string | undefined;
+    
+    targetAction: string | undefined;
+    
+    filters: WebhookFilterRule[] | undefined;
+    
+    authentication: WebhookAuthenticationType | string | undefined;
+    
+    authenticationConfiguration: WebhookAuthConfiguration | undefined;
+}
+export declare namespace WebhookDefinition {
+    
+    const filterSensitiveLog: (obj: WebhookDefinition) => any;
+}
+
+export interface ListWebhookItem {
+    
+    definition: WebhookDefinition | undefined;
+    
+    url: string | undefined;
+    
+    errorMessage?: string;
+    
+    errorCode?: string;
+    
+    lastTriggered?: Date;
+    
+    arn?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace ListWebhookItem {
+    
+    const filterSensitiveLog: (obj: ListWebhookItem) => any;
+}
+export interface ListWebhooksOutput {
+    
+    webhooks?: ListWebhookItem[];
+    
+    NextToken?: string;
+}
+export declare namespace ListWebhooksOutput {
+    
+    const filterSensitiveLog: (obj: ListWebhooksOutput) => any;
+}
+
+export interface PollForJobsInput {
+    
+    actionTypeId: ActionTypeId | undefined;
+    
+    maxBatchSize?: number;
+    
+    queryParam?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PollForJobsInput {
+    
+    const filterSensitiveLog: (obj: PollForJobsInput) => any;
+}
+
+export interface Job {
+    
+    id?: string;
+    
+    data?: JobData;
+    
+    nonce?: string;
+    
+    accountId?: string;
+}
+export declare namespace Job {
+    
+    const filterSensitiveLog: (obj: Job) => any;
+}
+
+export interface PollForJobsOutput {
+    
+    jobs?: Job[];
+}
+export declare namespace PollForJobsOutput {
+    
+    const filterSensitiveLog: (obj: PollForJobsOutput) => any;
+}
+
+export interface PollForThirdPartyJobsInput {
+    
+    actionTypeId: ActionTypeId | undefined;
+    
+    maxBatchSize?: number;
+}
+export declare namespace PollForThirdPartyJobsInput {
+    
+    const filterSensitiveLog: (obj: PollForThirdPartyJobsInput) => any;
+}
+
+export interface ThirdPartyJob {
+    
+    clientId?: string;
+    
+    jobId?: string;
+}
+export declare namespace ThirdPartyJob {
+    
+    const filterSensitiveLog: (obj: ThirdPartyJob) => any;
+}
+
+export interface PollForThirdPartyJobsOutput {
+    
+    jobs?: ThirdPartyJob[];
+}
+export declare namespace PollForThirdPartyJobsOutput {
+    
+    const filterSensitiveLog: (obj: PollForThirdPartyJobsOutput) => any;
+}
+
+export interface PutActionRevisionInput {
+    
+    pipelineName: string | undefined;
+    
+    stageName: string | undefined;
+    
+    actionName: string | undefined;
+    
+    actionRevision: ActionRevision | undefined;
+}
+export declare namespace PutActionRevisionInput {
+    
+    const filterSensitiveLog: (obj: PutActionRevisionInput) => any;
+}
+
+export interface PutActionRevisionOutput {
+    
+    newRevision?: boolean;
+    
+    pipelineExecutionId?: string;
+}
+export declare namespace PutActionRevisionOutput {
+    
+    const filterSensitiveLog: (obj: PutActionRevisionOutput) => any;
+}
+
+export interface InvalidApprovalTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidApprovalTokenException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidApprovalTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidApprovalTokenException) => any;
+}
+
+export interface PutApprovalResultInput {
+    
+    pipelineName: string | undefined;
+    
+    stageName: string | undefined;
+    
+    actionName: string | undefined;
+    
+    result: ApprovalResult | undefined;
+    
+    token: string | undefined;
+}
+export declare namespace PutApprovalResultInput {
+    
+    const filterSensitiveLog: (obj: PutApprovalResultInput) => any;
+}
+
+export interface PutApprovalResultOutput {
+    
+    approvedAt?: Date;
+}
+export declare namespace PutApprovalResultOutput {
+    
+    const filterSensitiveLog: (obj: PutApprovalResultOutput) => any;
+}
+
+export interface InvalidJobStateException extends __SmithyException, $MetadataBearer {
+    name: "InvalidJobStateException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidJobStateException {
+    
+    const filterSensitiveLog: (obj: InvalidJobStateException) => any;
+}
+export declare enum FailureType {
+    ConfigurationError = "ConfigurationError",
+    JobFailed = "JobFailed",
+    PermissionError = "PermissionError",
+    RevisionOutOfSync = "RevisionOutOfSync",
+    RevisionUnavailable = "RevisionUnavailable",
+    SystemUnavailable = "SystemUnavailable"
+}
+
+export interface FailureDetails {
+    
+    type: FailureType | string | undefined;
+    
+    message: string | undefined;
+    
+    externalExecutionId?: string;
+}
+export declare namespace FailureDetails {
+    
+    const filterSensitiveLog: (obj: FailureDetails) => any;
+}
+
+export interface PutJobFailureResultInput {
+    
+    jobId: string | undefined;
+    
+    failureDetails: FailureDetails | undefined;
+}
+export declare namespace PutJobFailureResultInput {
+    
+    const filterSensitiveLog: (obj: PutJobFailureResultInput) => any;
+}
+
+export interface OutputVariablesSizeExceededException extends __SmithyException, $MetadataBearer {
+    name: "OutputVariablesSizeExceededException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace OutputVariablesSizeExceededException {
+    
+    const filterSensitiveLog: (obj: OutputVariablesSizeExceededException) => any;
+}
+
+export interface CurrentRevision {
+    
+    revision: string | undefined;
+    
+    changeIdentifier: string | undefined;
+    
+    created?: Date;
+    
+    revisionSummary?: string;
+}
+export declare namespace CurrentRevision {
+    
+    const filterSensitiveLog: (obj: CurrentRevision) => any;
+}
+
+export interface ExecutionDetails {
+    
+    summary?: string;
+    
+    externalExecutionId?: string;
+    
+    percentComplete?: number;
+}
+export declare namespace ExecutionDetails {
+    
+    const filterSensitiveLog: (obj: ExecutionDetails) => any;
+}
+
+export interface PutJobSuccessResultInput {
+    
+    jobId: string | undefined;
+    
+    currentRevision?: CurrentRevision;
+    
+    continuationToken?: string;
+    
+    executionDetails?: ExecutionDetails;
+    
+    outputVariables?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PutJobSuccessResultInput {
+    
+    const filterSensitiveLog: (obj: PutJobSuccessResultInput) => any;
+}
+
+export interface PutThirdPartyJobFailureResultInput {
+    
+    jobId: string | undefined;
+    
+    clientToken: string | undefined;
+    
+    failureDetails: FailureDetails | undefined;
+}
+export declare namespace PutThirdPartyJobFailureResultInput {
+    
+    const filterSensitiveLog: (obj: PutThirdPartyJobFailureResultInput) => any;
+}
+
+export interface PutThirdPartyJobSuccessResultInput {
+    
+    jobId: string | undefined;
+    
+    clientToken: string | undefined;
+    
+    currentRevision?: CurrentRevision;
+    
+    continuationToken?: string;
+    
+    executionDetails?: ExecutionDetails;
+}
+export declare namespace PutThirdPartyJobSuccessResultInput {
+    
+    const filterSensitiveLog: (obj: PutThirdPartyJobSuccessResultInput) => any;
+}
+
+export interface InvalidWebhookAuthenticationParametersException extends __SmithyException, $MetadataBearer {
+    name: "InvalidWebhookAuthenticationParametersException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidWebhookAuthenticationParametersException {
+    
+    const filterSensitiveLog: (obj: InvalidWebhookAuthenticationParametersException) => any;
+}
+
+export interface InvalidWebhookFilterPatternException extends __SmithyException, $MetadataBearer {
+    name: "InvalidWebhookFilterPatternException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidWebhookFilterPatternException {
+    
+    const filterSensitiveLog: (obj: InvalidWebhookFilterPatternException) => any;
+}
+export interface PutWebhookInput {
+    
+    webhook: WebhookDefinition | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace PutWebhookInput {
+    
+    const filterSensitiveLog: (obj: PutWebhookInput) => any;
+}
+export interface PutWebhookOutput {
+    
+    webhook?: ListWebhookItem;
+}
+export declare namespace PutWebhookOutput {
+    
+    const filterSensitiveLog: (obj: PutWebhookOutput) => any;
+}
+export interface RegisterWebhookWithThirdPartyInput {
+    
+    webhookName?: string;
+}
+export declare namespace RegisterWebhookWithThirdPartyInput {
+    
+    const filterSensitiveLog: (obj: RegisterWebhookWithThirdPartyInput) => any;
+}
+export interface RegisterWebhookWithThirdPartyOutput {
+}
+export declare namespace RegisterWebhookWithThirdPartyOutput {
+    
+    const filterSensitiveLog: (obj: RegisterWebhookWithThirdPartyOutput) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface NotLatestPipelineExecutionException extends __SmithyException, $MetadataBearer {
+    name: "NotLatestPipelineExecutionException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace NotLatestPipelineExecutionException {
+    
+    const filterSensitiveLog: (obj: NotLatestPipelineExecutionException) => any;
+}
+export declare enum StageRetryMode {
+    FAILED_ACTIONS = "FAILED_ACTIONS"
+}
+
+export interface RetryStageExecutionInput {
+    
+    pipelineName: string | undefined;
+    
+    stageName: string | undefined;
+    
+    pipelineExecutionId: string | undefined;
+    
+    retryMode: StageRetryMode | string | undefined;
+}
+export declare namespace RetryStageExecutionInput {
+    
+    const filterSensitiveLog: (obj: RetryStageExecutionInput) => any;
+}
+
+export interface RetryStageExecutionOutput {
+    
+    pipelineExecutionId?: string;
+}
+export declare namespace RetryStageExecutionOutput {
+    
+    const filterSensitiveLog: (obj: RetryStageExecutionOutput) => any;
+}
+
+export interface StageNotRetryableException extends __SmithyException, $MetadataBearer {
+    name: "StageNotRetryableException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace StageNotRetryableException {
+    
+    const filterSensitiveLog: (obj: StageNotRetryableException) => any;
+}
+
+export interface StartPipelineExecutionInput {
+    
+    name: string | undefined;
+    
+    clientRequestToken?: string;
+}
+export declare namespace StartPipelineExecutionInput {
+    
+    const filterSensitiveLog: (obj: StartPipelineExecutionInput) => any;
+}
+
+export interface StartPipelineExecutionOutput {
+    
+    pipelineExecutionId?: string;
+}
+export declare namespace StartPipelineExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StartPipelineExecutionOutput) => any;
+}
+
+export interface DuplicatedStopRequestException extends __SmithyException, $MetadataBearer {
+    name: "DuplicatedStopRequestException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace DuplicatedStopRequestException {
+    
+    const filterSensitiveLog: (obj: DuplicatedStopRequestException) => any;
+}
+
+export interface PipelineExecutionNotStoppableException extends __SmithyException, $MetadataBearer {
+    name: "PipelineExecutionNotStoppableException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace PipelineExecutionNotStoppableException {
+    
+    const filterSensitiveLog: (obj: PipelineExecutionNotStoppableException) => any;
+}
+export interface StopPipelineExecutionInput {
+    
+    pipelineName: string | undefined;
+    
+    pipelineExecutionId: string | undefined;
+    
+    abandon?: boolean;
+    
+    reason?: string;
+}
+export declare namespace StopPipelineExecutionInput {
+    
+    const filterSensitiveLog: (obj: StopPipelineExecutionInput) => any;
+}
+export interface StopPipelineExecutionOutput {
+    
+    pipelineExecutionId?: string;
+}
+export declare namespace StopPipelineExecutionOutput {
+    
+    const filterSensitiveLog: (obj: StopPipelineExecutionOutput) => any;
+}
+export interface TagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+export interface TagResourceOutput {
+}
+export declare namespace TagResourceOutput {
+    
+    const filterSensitiveLog: (obj: TagResourceOutput) => any;
+}
+export interface UntagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+export interface UntagResourceOutput {
+}
+export declare namespace UntagResourceOutput {
+    
+    const filterSensitiveLog: (obj: UntagResourceOutput) => any;
+}
+
+export interface RequestFailedException extends __SmithyException, $MetadataBearer {
+    name: "RequestFailedException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace RequestFailedException {
+    
+    const filterSensitiveLog: (obj: RequestFailedException) => any;
+}
+export interface UpdateActionTypeInput {
+    
+    actionType: ActionTypeDeclaration | undefined;
+}
+export declare namespace UpdateActionTypeInput {
+    
+    const filterSensitiveLog: (obj: UpdateActionTypeInput) => any;
+}
+
+export interface UpdatePipelineInput {
+    
+    pipeline: PipelineDeclaration | undefined;
+}
+export declare namespace UpdatePipelineInput {
+    
+    const filterSensitiveLog: (obj: UpdatePipelineInput) => any;
+}
+
+export interface UpdatePipelineOutput {
+    
+    pipeline?: PipelineDeclaration;
+}
+export declare namespace UpdatePipelineOutput {
+    
+    const filterSensitiveLog: (obj: UpdatePipelineOutput) => any;
+}