import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
import { CodePipelineServiceException as __BaseException } from "./CodePipelineServiceException";

export interface AcknowledgeJobInput {
    
    jobId: string | undefined;
    
    nonce: string | undefined;
}
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 class InvalidNonceException extends __BaseException {
    readonly name: "InvalidNonceException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidNonceException, __BaseException>);
}

export declare class JobNotFoundException extends __BaseException {
    readonly name: "JobNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<JobNotFoundException, __BaseException>);
}

export declare class ValidationException extends __BaseException {
    readonly name: "ValidationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
}

export interface AcknowledgeThirdPartyJobInput {
    
    jobId: string | undefined;
    
    nonce: string | undefined;
    
    clientToken: string | undefined;
}

export interface AcknowledgeThirdPartyJobOutput {
    
    status?: JobStatus | string;
}

export declare class InvalidClientTokenException extends __BaseException {
    readonly name: "InvalidClientTokenException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidClientTokenException, __BaseException>);
}
export declare enum ActionCategory {
    Approval = "Approval",
    Build = "Build",
    Deploy = "Deploy",
    Invoke = "Invoke",
    Source = "Source",
    Test = "Test"
}

export interface ActionConfiguration {
    
    configuration?: Record<string, string>;
}
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 interface ActionContext {
    
    name?: string;
    
    actionExecutionId?: string;
}
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 interface InputArtifact {
    
    name: string | undefined;
}

export interface OutputArtifact {
    
    name: string | undefined;
}

export interface ActionDeclaration {
    
    name: string | undefined;
    
    actionTypeId: ActionTypeId | undefined;
    
    runOrder?: number;
    
    configuration?: Record<string, string>;
    
    outputArtifacts?: OutputArtifact[];
    
    inputArtifacts?: InputArtifact[];
    
    roleArn?: string;
    
    region?: string;
    
    namespace?: string;
}

export interface ErrorDetails {
    
    code?: string;
    
    message?: string;
}
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 interface S3Location {
    
    bucket?: string;
    
    key?: string;
}

export interface ArtifactDetail {
    
    name?: string;
    
    s3location?: S3Location;
}

export interface ActionExecutionInput {
    
    actionTypeId?: ActionTypeId;
    
    configuration?: Record<string, string>;
    
    resolvedConfiguration?: Record<string, string>;
    
    roleArn?: string;
    
    region?: string;
    
    inputArtifacts?: ArtifactDetail[];
    
    namespace?: string;
}

export interface ActionExecutionResult {
    
    externalExecutionId?: string;
    
    externalExecutionSummary?: string;
    
    externalExecutionUrl?: string;
}

export interface ActionExecutionOutput {
    
    outputArtifacts?: ArtifactDetail[];
    
    executionResult?: ActionExecutionResult;
    
    outputVariables?: Record<string, string>;
}

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 interface ActionExecutionFilter {
    
    pipelineExecutionId?: string;
}

export declare class ActionNotFoundException extends __BaseException {
    readonly name: "ActionNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ActionNotFoundException, __BaseException>);
}

export interface ActionRevision {
    
    revisionId: string | undefined;
    
    revisionChangeId: string | undefined;
    
    created: Date | undefined;
}

export interface ActionState {
    
    actionName?: string;
    
    currentRevision?: ActionRevision;
    
    latestExecution?: ActionExecution;
    
    entityUrl?: string;
    
    revisionUrl?: string;
}

export interface ArtifactDetails {
    
    minimumCount: number | undefined;
    
    maximumCount: number | undefined;
}

export interface ActionTypeSettings {
    
    thirdPartyConfigurationUrl?: string;
    
    entityUrlTemplate?: string;
    
    executionUrlTemplate?: string;
    
    revisionUrlTemplate?: string;
}

export interface ActionType {
    
    id: ActionTypeId | undefined;
    
    settings?: ActionTypeSettings;
    
    actionConfigurationProperties?: ActionConfigurationProperty[];
    
    inputArtifactDetails: ArtifactDetails | undefined;
    
    outputArtifactDetails: ArtifactDetails | undefined;
}

export interface ActionTypeArtifactDetails {
    
    minimumCount: number | undefined;
    
    maximumCount: number | undefined;
}

export interface JobWorkerExecutorConfiguration {
    
    pollingAccounts?: string[];
    
    pollingServicePrincipals?: string[];
}

export interface LambdaExecutorConfiguration {
    
    lambdaFunctionArn: string | undefined;
}

export interface ExecutorConfiguration {
    
    lambdaExecutorConfiguration?: LambdaExecutorConfiguration;
    
    jobWorkerExecutorConfiguration?: JobWorkerExecutorConfiguration;
}
export declare enum ExecutorType {
    JobWorker = "JobWorker",
    Lambda = "Lambda"
}

export interface ActionTypeExecutor {
    
    configuration: ExecutorConfiguration | undefined;
    
    type: ExecutorType | string | undefined;
    
    policyStatementsTemplate?: string;
    
    jobTimeout?: number;
}

export interface ActionTypeIdentifier {
    
    category: ActionCategory | string | undefined;
    
    owner: string | undefined;
    
    provider: string | undefined;
    
    version: string | undefined;
}

export interface ActionTypePermissions {
    
    allowedAccounts: string[] | undefined;
}

export interface ActionTypeProperty {
    
    name: string | undefined;
    
    optional: boolean | undefined;
    
    key: boolean | undefined;
    
    noEcho: boolean | undefined;
    
    queryable?: boolean;
    
    description?: string;
}

export interface ActionTypeUrls {
    
    configurationUrl?: string;
    
    entityUrlTemplate?: string;
    
    executionUrlTemplate?: string;
    
    revisionUrlTemplate?: string;
}

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 class ActionTypeNotFoundException extends __BaseException {
    readonly name: "ActionTypeNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ActionTypeNotFoundException, __BaseException>);
}

export declare class ApprovalAlreadyCompletedException extends __BaseException {
    readonly name: "ApprovalAlreadyCompletedException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ApprovalAlreadyCompletedException, __BaseException>);
}
export declare enum ApprovalStatus {
    Approved = "Approved",
    Rejected = "Rejected"
}

export interface ApprovalResult {
    
    summary: string | undefined;
    
    status: ApprovalStatus | string | undefined;
}

export interface S3ArtifactLocation {
    
    bucketName: string | undefined;
    
    objectKey: string | undefined;
}
export declare enum ArtifactLocationType {
    S3 = "S3"
}

export interface ArtifactLocation {
    
    type?: ArtifactLocationType | string;
    
    s3Location?: S3ArtifactLocation;
}

export interface Artifact {
    
    name?: string;
    
    revision?: string;
    
    location?: ArtifactLocation;
}

export interface ArtifactRevision {
    
    name?: string;
    
    revisionId?: string;
    
    revisionChangeIdentifier?: string;
    
    revisionSummary?: string;
    
    created?: Date;
    
    revisionUrl?: string;
}
export declare enum EncryptionKeyType {
    KMS = "KMS"
}

export interface EncryptionKey {
    
    id: string | undefined;
    
    type: EncryptionKeyType | string | undefined;
}
export declare enum ArtifactStoreType {
    S3 = "S3"
}

export interface ArtifactStore {
    
    type: ArtifactStoreType | string | undefined;
    
    location: string | undefined;
    
    encryptionKey?: EncryptionKey;
}

export interface AWSSessionCredentials {
    
    accessKeyId: string | undefined;
    
    secretAccessKey: string | undefined;
    
    sessionToken: string | undefined;
}
export declare enum BlockerType {
    Schedule = "Schedule"
}

export interface BlockerDeclaration {
    
    name: string | undefined;
    
    type: BlockerType | string | undefined;
}

export declare class ConcurrentModificationException extends __BaseException {
    readonly name: "ConcurrentModificationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
}

export interface Tag {
    
    key: string | undefined;
    
    value: string | undefined;
}

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 interface CreateCustomActionTypeOutput {
    
    actionType: ActionType | undefined;
    
    tags?: Tag[];
}

export declare class InvalidTagsException extends __BaseException {
    readonly name: "InvalidTagsException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidTagsException, __BaseException>);
}

export declare class LimitExceededException extends __BaseException {
    readonly name: "LimitExceededException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
}

export declare class TooManyTagsException extends __BaseException {
    readonly name: "TooManyTagsException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
}

export interface StageDeclaration {
    
    name: string | undefined;
    
    blockers?: BlockerDeclaration[];
    
    actions: ActionDeclaration[] | undefined;
}

export interface PipelineDeclaration {
    
    name: string | undefined;
    
    roleArn: string | undefined;
    
    artifactStore?: ArtifactStore;
    
    artifactStores?: Record<string, ArtifactStore>;
    
    stages: StageDeclaration[] | undefined;
    
    version?: number;
}

export interface CreatePipelineInput {
    
    pipeline: PipelineDeclaration | undefined;
    
    tags?: Tag[];
}

export interface CreatePipelineOutput {
    
    pipeline?: PipelineDeclaration;
    
    tags?: Tag[];
}

export declare class InvalidActionDeclarationException extends __BaseException {
    readonly name: "InvalidActionDeclarationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidActionDeclarationException, __BaseException>);
}

export declare class InvalidBlockerDeclarationException extends __BaseException {
    readonly name: "InvalidBlockerDeclarationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidBlockerDeclarationException, __BaseException>);
}

export declare class InvalidStageDeclarationException extends __BaseException {
    readonly name: "InvalidStageDeclarationException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidStageDeclarationException, __BaseException>);
}

export declare class InvalidStructureException extends __BaseException {
    readonly name: "InvalidStructureException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidStructureException, __BaseException>);
}

export declare class PipelineNameInUseException extends __BaseException {
    readonly name: "PipelineNameInUseException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PipelineNameInUseException, __BaseException>);
}

export interface DeleteCustomActionTypeInput {
    
    category: ActionCategory | string | undefined;
    
    provider: string | undefined;
    
    version: string | undefined;
}

export interface DeletePipelineInput {
    
    name: string | undefined;
}
export interface DeleteWebhookInput {
    
    name: string | undefined;
}
export interface DeleteWebhookOutput {
}
export interface DeregisterWebhookWithThirdPartyInput {
    
    webhookName?: string;
}
export interface DeregisterWebhookWithThirdPartyOutput {
}

export declare class WebhookNotFoundException extends __BaseException {
    readonly name: "WebhookNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<WebhookNotFoundException, __BaseException>);
}
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 class PipelineNotFoundException extends __BaseException {
    readonly name: "PipelineNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PipelineNotFoundException, __BaseException>);
}

export declare class StageNotFoundException extends __BaseException {
    readonly name: "StageNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<StageNotFoundException, __BaseException>);
}

export interface EnableStageTransitionInput {
    
    pipelineName: string | undefined;
    
    stageName: string | undefined;
    
    transitionType: StageTransitionType | string | undefined;
}
export interface GetActionTypeInput {
    
    category: ActionCategory | string | undefined;
    
    owner: string | undefined;
    
    provider: string | undefined;
    
    version: string | undefined;
}
export interface GetActionTypeOutput {
    
    actionType?: ActionTypeDeclaration;
}

export interface GetJobDetailsInput {
    
    jobId: string | undefined;
}

export interface StageContext {
    
    name?: string;
}

export interface PipelineContext {
    
    pipelineName?: string;
    
    stage?: StageContext;
    
    action?: ActionContext;
    
    pipelineArn?: string;
    
    pipelineExecutionId?: string;
}

export interface JobData {
    
    actionTypeId?: ActionTypeId;
    
    actionConfiguration?: ActionConfiguration;
    
    pipelineContext?: PipelineContext;
    
    inputArtifacts?: Artifact[];
    
    outputArtifacts?: Artifact[];
    
    artifactCredentials?: AWSSessionCredentials;
    
    continuationToken?: string;
    
    encryptionKey?: EncryptionKey;
}

export interface JobDetails {
    
    id?: string;
    
    data?: JobData;
    
    accountId?: string;
}

export interface GetJobDetailsOutput {
    
    jobDetails?: JobDetails;
}

export interface GetPipelineInput {
    
    name: string | undefined;
    
    version?: number;
}

export interface PipelineMetadata {
    
    pipelineArn?: string;
    
    created?: Date;
    
    updated?: Date;
}

export interface GetPipelineOutput {
    
    pipeline?: PipelineDeclaration;
    
    metadata?: PipelineMetadata;
}

export declare class PipelineVersionNotFoundException extends __BaseException {
    readonly name: "PipelineVersionNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PipelineVersionNotFoundException, __BaseException>);
}

export interface GetPipelineExecutionInput {
    
    pipelineName: string | undefined;
    
    pipelineExecutionId: string | undefined;
}
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 interface GetPipelineExecutionOutput {
    
    pipelineExecution?: PipelineExecution;
}

export declare class PipelineExecutionNotFoundException extends __BaseException {
    readonly name: "PipelineExecutionNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PipelineExecutionNotFoundException, __BaseException>);
}

export interface GetPipelineStateInput {
    
    name: string | undefined;
}
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 interface TransitionState {
    
    enabled?: boolean;
    
    lastChangedBy?: string;
    
    lastChangedAt?: Date;
    
    disabledReason?: string;
}

export interface StageState {
    
    stageName?: string;
    
    inboundExecution?: StageExecution;
    
    inboundTransitionState?: TransitionState;
    
    actionStates?: ActionState[];
    
    latestExecution?: StageExecution;
}

export interface GetPipelineStateOutput {
    
    pipelineName?: string;
    
    pipelineVersion?: number;
    
    stageStates?: StageState[];
    
    created?: Date;
    
    updated?: Date;
}

export interface GetThirdPartyJobDetailsInput {
    
    jobId: string | undefined;
    
    clientToken: string | undefined;
}

export interface ThirdPartyJobData {
    
    actionTypeId?: ActionTypeId;
    
    actionConfiguration?: ActionConfiguration;
    
    pipelineContext?: PipelineContext;
    
    inputArtifacts?: Artifact[];
    
    outputArtifacts?: Artifact[];
    
    artifactCredentials?: AWSSessionCredentials;
    
    continuationToken?: string;
    
    encryptionKey?: EncryptionKey;
}

export interface ThirdPartyJobDetails {
    
    id?: string;
    
    data?: ThirdPartyJobData;
    
    nonce?: string;
}

export interface GetThirdPartyJobDetailsOutput {
    
    jobDetails?: ThirdPartyJobDetails;
}

export declare class InvalidJobException extends __BaseException {
    readonly name: "InvalidJobException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidJobException, __BaseException>);
}

export declare class InvalidNextTokenException extends __BaseException {
    readonly name: "InvalidNextTokenException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
}
export interface ListActionExecutionsInput {
    
    pipelineName: string | undefined;
    
    filter?: ActionExecutionFilter;
    
    maxResults?: number;
    
    nextToken?: string;
}
export interface ListActionExecutionsOutput {
    
    actionExecutionDetails?: ActionExecutionDetail[];
    
    nextToken?: string;
}

export interface ListActionTypesInput {
    
    actionOwnerFilter?: ActionOwner | string;
    
    nextToken?: string;
    
    regionFilter?: string;
}

export interface ListActionTypesOutput {
    
    actionTypes: ActionType[] | undefined;
    
    nextToken?: string;
}

export interface ListPipelineExecutionsInput {
    
    pipelineName: string | undefined;
    
    maxResults?: number;
    
    nextToken?: string;
}

export interface SourceRevision {
    
    actionName: string | undefined;
    
    revisionId?: string;
    
    revisionSummary?: string;
    
    revisionUrl?: string;
}

export interface StopExecutionTrigger {
    
    reason?: string;
}
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 interface PipelineExecutionSummary {
    
    pipelineExecutionId?: string;
    
    status?: PipelineExecutionStatus | string;
    
    startTime?: Date;
    
    lastUpdateTime?: Date;
    
    sourceRevisions?: SourceRevision[];
    
    trigger?: ExecutionTrigger;
    
    stopTrigger?: StopExecutionTrigger;
}

export interface ListPipelineExecutionsOutput {
    
    pipelineExecutionSummaries?: PipelineExecutionSummary[];
    
    nextToken?: string;
}

export interface ListPipelinesInput {
    
    nextToken?: string;
    
    maxResults?: number;
}

export interface PipelineSummary {
    
    name?: string;
    
    version?: number;
    
    created?: Date;
    
    updated?: Date;
}

export interface ListPipelinesOutput {
    
    pipelines?: PipelineSummary[];
    
    nextToken?: string;
}

export declare class InvalidArnException extends __BaseException {
    readonly name: "InvalidArnException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidArnException, __BaseException>);
}
export interface ListTagsForResourceInput {
    
    resourceArn: string | undefined;
    
    nextToken?: string;
    
    maxResults?: number;
}
export interface ListTagsForResourceOutput {
    
    tags?: Tag[];
    
    nextToken?: string;
}

export declare class ResourceNotFoundException extends __BaseException {
    readonly name: "ResourceNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
}
export interface ListWebhooksInput {
    
    NextToken?: string;
    
    MaxResults?: number;
}
export declare enum WebhookAuthenticationType {
    GITHUB_HMAC = "GITHUB_HMAC",
    IP = "IP",
    UNAUTHENTICATED = "UNAUTHENTICATED"
}

export interface WebhookAuthConfiguration {
    
    AllowedIPRange?: string;
    
    SecretToken?: string;
}

export interface WebhookFilterRule {
    
    jsonPath: string | undefined;
    
    matchEquals?: string;
}

export interface WebhookDefinition {
    
    name: string | undefined;
    
    targetPipeline: string | undefined;
    
    targetAction: string | undefined;
    
    filters: WebhookFilterRule[] | undefined;
    
    authentication: WebhookAuthenticationType | string | undefined;
    
    authenticationConfiguration: WebhookAuthConfiguration | undefined;
}

export interface ListWebhookItem {
    
    definition: WebhookDefinition | undefined;
    
    url: string | undefined;
    
    errorMessage?: string;
    
    errorCode?: string;
    
    lastTriggered?: Date;
    
    arn?: string;
    
    tags?: Tag[];
}
export interface ListWebhooksOutput {
    
    webhooks?: ListWebhookItem[];
    
    NextToken?: string;
}

export interface PollForJobsInput {
    
    actionTypeId: ActionTypeId | undefined;
    
    maxBatchSize?: number;
    
    queryParam?: Record<string, string>;
}

export interface Job {
    
    id?: string;
    
    data?: JobData;
    
    nonce?: string;
    
    accountId?: string;
}

export interface PollForJobsOutput {
    
    jobs?: Job[];
}

export interface PollForThirdPartyJobsInput {
    
    actionTypeId: ActionTypeId | undefined;
    
    maxBatchSize?: number;
}

export interface ThirdPartyJob {
    
    clientId?: string;
    
    jobId?: string;
}

export interface PollForThirdPartyJobsOutput {
    
    jobs?: ThirdPartyJob[];
}

export interface PutActionRevisionInput {
    
    pipelineName: string | undefined;
    
    stageName: string | undefined;
    
    actionName: string | undefined;
    
    actionRevision: ActionRevision | undefined;
}

export interface PutActionRevisionOutput {
    
    newRevision?: boolean;
    
    pipelineExecutionId?: string;
}

export declare class InvalidApprovalTokenException extends __BaseException {
    readonly name: "InvalidApprovalTokenException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidApprovalTokenException, __BaseException>);
}

export interface PutApprovalResultInput {
    
    pipelineName: string | undefined;
    
    stageName: string | undefined;
    
    actionName: string | undefined;
    
    result: ApprovalResult | undefined;
    
    token: string | undefined;
}

export interface PutApprovalResultOutput {
    
    approvedAt?: Date;
}

export declare class InvalidJobStateException extends __BaseException {
    readonly name: "InvalidJobStateException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidJobStateException, __BaseException>);
}
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 interface PutJobFailureResultInput {
    
    jobId: string | undefined;
    
    failureDetails: FailureDetails | undefined;
}

export declare class OutputVariablesSizeExceededException extends __BaseException {
    readonly name: "OutputVariablesSizeExceededException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<OutputVariablesSizeExceededException, __BaseException>);
}

export interface CurrentRevision {
    
    revision: string | undefined;
    
    changeIdentifier: string | undefined;
    
    created?: Date;
    
    revisionSummary?: string;
}

export interface ExecutionDetails {
    
    summary?: string;
    
    externalExecutionId?: string;
    
    percentComplete?: number;
}

export interface PutJobSuccessResultInput {
    
    jobId: string | undefined;
    
    currentRevision?: CurrentRevision;
    
    continuationToken?: string;
    
    executionDetails?: ExecutionDetails;
    
    outputVariables?: Record<string, string>;
}

export interface PutThirdPartyJobFailureResultInput {
    
    jobId: string | undefined;
    
    clientToken: string | undefined;
    
    failureDetails: FailureDetails | undefined;
}

export interface PutThirdPartyJobSuccessResultInput {
    
    jobId: string | undefined;
    
    clientToken: string | undefined;
    
    currentRevision?: CurrentRevision;
    
    continuationToken?: string;
    
    executionDetails?: ExecutionDetails;
}

export declare class InvalidWebhookAuthenticationParametersException extends __BaseException {
    readonly name: "InvalidWebhookAuthenticationParametersException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidWebhookAuthenticationParametersException, __BaseException>);
}

export declare class InvalidWebhookFilterPatternException extends __BaseException {
    readonly name: "InvalidWebhookFilterPatternException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidWebhookFilterPatternException, __BaseException>);
}
export interface PutWebhookInput {
    
    webhook: WebhookDefinition | undefined;
    
    tags?: Tag[];
}
export interface PutWebhookOutput {
    
    webhook?: ListWebhookItem;
}
export interface RegisterWebhookWithThirdPartyInput {
    
    webhookName?: string;
}
export interface RegisterWebhookWithThirdPartyOutput {
}

export declare class ConflictException extends __BaseException {
    readonly name: "ConflictException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
}

export declare class NotLatestPipelineExecutionException extends __BaseException {
    readonly name: "NotLatestPipelineExecutionException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<NotLatestPipelineExecutionException, __BaseException>);
}
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 interface RetryStageExecutionOutput {
    
    pipelineExecutionId?: string;
}

export declare class StageNotRetryableException extends __BaseException {
    readonly name: "StageNotRetryableException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<StageNotRetryableException, __BaseException>);
}

export interface StartPipelineExecutionInput {
    
    name: string | undefined;
    
    clientRequestToken?: string;
}

export interface StartPipelineExecutionOutput {
    
    pipelineExecutionId?: string;
}

export declare class DuplicatedStopRequestException extends __BaseException {
    readonly name: "DuplicatedStopRequestException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<DuplicatedStopRequestException, __BaseException>);
}

export declare class PipelineExecutionNotStoppableException extends __BaseException {
    readonly name: "PipelineExecutionNotStoppableException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<PipelineExecutionNotStoppableException, __BaseException>);
}
export interface StopPipelineExecutionInput {
    
    pipelineName: string | undefined;
    
    pipelineExecutionId: string | undefined;
    
    abandon?: boolean;
    
    reason?: string;
}
export interface StopPipelineExecutionOutput {
    
    pipelineExecutionId?: string;
}
export interface TagResourceInput {
    
    resourceArn: string | undefined;
    
    tags: Tag[] | undefined;
}
export interface TagResourceOutput {
}
export interface UntagResourceInput {
    
    resourceArn: string | undefined;
    
    tagKeys: string[] | undefined;
}
export interface UntagResourceOutput {
}

export declare class RequestFailedException extends __BaseException {
    readonly name: "RequestFailedException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<RequestFailedException, __BaseException>);
}
export interface UpdateActionTypeInput {
    
    actionType: ActionTypeDeclaration | undefined;
}

export interface UpdatePipelineInput {
    
    pipeline: PipelineDeclaration | undefined;
}

export interface UpdatePipelineOutput {
    
    pipeline?: PipelineDeclaration;
}

export declare const AcknowledgeJobInputFilterSensitiveLog: (obj: AcknowledgeJobInput) => any;

export declare const AcknowledgeJobOutputFilterSensitiveLog: (obj: AcknowledgeJobOutput) => any;

export declare const AcknowledgeThirdPartyJobInputFilterSensitiveLog: (obj: AcknowledgeThirdPartyJobInput) => any;

export declare const AcknowledgeThirdPartyJobOutputFilterSensitiveLog: (obj: AcknowledgeThirdPartyJobOutput) => any;

export declare const ActionConfigurationFilterSensitiveLog: (obj: ActionConfiguration) => any;

export declare const ActionConfigurationPropertyFilterSensitiveLog: (obj: ActionConfigurationProperty) => any;

export declare const ActionContextFilterSensitiveLog: (obj: ActionContext) => any;

export declare const ActionTypeIdFilterSensitiveLog: (obj: ActionTypeId) => any;

export declare const InputArtifactFilterSensitiveLog: (obj: InputArtifact) => any;

export declare const OutputArtifactFilterSensitiveLog: (obj: OutputArtifact) => any;

export declare const ActionDeclarationFilterSensitiveLog: (obj: ActionDeclaration) => any;

export declare const ErrorDetailsFilterSensitiveLog: (obj: ErrorDetails) => any;

export declare const ActionExecutionFilterSensitiveLog: (obj: ActionExecution) => any;

export declare const S3LocationFilterSensitiveLog: (obj: S3Location) => any;

export declare const ArtifactDetailFilterSensitiveLog: (obj: ArtifactDetail) => any;

export declare const ActionExecutionInputFilterSensitiveLog: (obj: ActionExecutionInput) => any;

export declare const ActionExecutionResultFilterSensitiveLog: (obj: ActionExecutionResult) => any;

export declare const ActionExecutionOutputFilterSensitiveLog: (obj: ActionExecutionOutput) => any;

export declare const ActionExecutionDetailFilterSensitiveLog: (obj: ActionExecutionDetail) => any;

export declare const ActionExecutionFilterFilterSensitiveLog: (obj: ActionExecutionFilter) => any;

export declare const ActionRevisionFilterSensitiveLog: (obj: ActionRevision) => any;

export declare const ActionStateFilterSensitiveLog: (obj: ActionState) => any;

export declare const ArtifactDetailsFilterSensitiveLog: (obj: ArtifactDetails) => any;

export declare const ActionTypeSettingsFilterSensitiveLog: (obj: ActionTypeSettings) => any;

export declare const ActionTypeFilterSensitiveLog: (obj: ActionType) => any;

export declare const ActionTypeArtifactDetailsFilterSensitiveLog: (obj: ActionTypeArtifactDetails) => any;

export declare const JobWorkerExecutorConfigurationFilterSensitiveLog: (obj: JobWorkerExecutorConfiguration) => any;

export declare const LambdaExecutorConfigurationFilterSensitiveLog: (obj: LambdaExecutorConfiguration) => any;

export declare const ExecutorConfigurationFilterSensitiveLog: (obj: ExecutorConfiguration) => any;

export declare const ActionTypeExecutorFilterSensitiveLog: (obj: ActionTypeExecutor) => any;

export declare const ActionTypeIdentifierFilterSensitiveLog: (obj: ActionTypeIdentifier) => any;

export declare const ActionTypePermissionsFilterSensitiveLog: (obj: ActionTypePermissions) => any;

export declare const ActionTypePropertyFilterSensitiveLog: (obj: ActionTypeProperty) => any;

export declare const ActionTypeUrlsFilterSensitiveLog: (obj: ActionTypeUrls) => any;

export declare const ActionTypeDeclarationFilterSensitiveLog: (obj: ActionTypeDeclaration) => any;

export declare const ApprovalResultFilterSensitiveLog: (obj: ApprovalResult) => any;

export declare const S3ArtifactLocationFilterSensitiveLog: (obj: S3ArtifactLocation) => any;

export declare const ArtifactLocationFilterSensitiveLog: (obj: ArtifactLocation) => any;

export declare const ArtifactFilterSensitiveLog: (obj: Artifact) => any;

export declare const ArtifactRevisionFilterSensitiveLog: (obj: ArtifactRevision) => any;

export declare const EncryptionKeyFilterSensitiveLog: (obj: EncryptionKey) => any;

export declare const ArtifactStoreFilterSensitiveLog: (obj: ArtifactStore) => any;

export declare const AWSSessionCredentialsFilterSensitiveLog: (obj: AWSSessionCredentials) => any;

export declare const BlockerDeclarationFilterSensitiveLog: (obj: BlockerDeclaration) => any;

export declare const TagFilterSensitiveLog: (obj: Tag) => any;

export declare const CreateCustomActionTypeInputFilterSensitiveLog: (obj: CreateCustomActionTypeInput) => any;

export declare const CreateCustomActionTypeOutputFilterSensitiveLog: (obj: CreateCustomActionTypeOutput) => any;

export declare const StageDeclarationFilterSensitiveLog: (obj: StageDeclaration) => any;

export declare const PipelineDeclarationFilterSensitiveLog: (obj: PipelineDeclaration) => any;

export declare const CreatePipelineInputFilterSensitiveLog: (obj: CreatePipelineInput) => any;

export declare const CreatePipelineOutputFilterSensitiveLog: (obj: CreatePipelineOutput) => any;

export declare const DeleteCustomActionTypeInputFilterSensitiveLog: (obj: DeleteCustomActionTypeInput) => any;

export declare const DeletePipelineInputFilterSensitiveLog: (obj: DeletePipelineInput) => any;

export declare const DeleteWebhookInputFilterSensitiveLog: (obj: DeleteWebhookInput) => any;

export declare const DeleteWebhookOutputFilterSensitiveLog: (obj: DeleteWebhookOutput) => any;

export declare const DeregisterWebhookWithThirdPartyInputFilterSensitiveLog: (obj: DeregisterWebhookWithThirdPartyInput) => any;

export declare const DeregisterWebhookWithThirdPartyOutputFilterSensitiveLog: (obj: DeregisterWebhookWithThirdPartyOutput) => any;

export declare const DisableStageTransitionInputFilterSensitiveLog: (obj: DisableStageTransitionInput) => any;

export declare const EnableStageTransitionInputFilterSensitiveLog: (obj: EnableStageTransitionInput) => any;

export declare const GetActionTypeInputFilterSensitiveLog: (obj: GetActionTypeInput) => any;

export declare const GetActionTypeOutputFilterSensitiveLog: (obj: GetActionTypeOutput) => any;

export declare const GetJobDetailsInputFilterSensitiveLog: (obj: GetJobDetailsInput) => any;

export declare const StageContextFilterSensitiveLog: (obj: StageContext) => any;

export declare const PipelineContextFilterSensitiveLog: (obj: PipelineContext) => any;

export declare const JobDataFilterSensitiveLog: (obj: JobData) => any;

export declare const JobDetailsFilterSensitiveLog: (obj: JobDetails) => any;

export declare const GetJobDetailsOutputFilterSensitiveLog: (obj: GetJobDetailsOutput) => any;

export declare const GetPipelineInputFilterSensitiveLog: (obj: GetPipelineInput) => any;

export declare const PipelineMetadataFilterSensitiveLog: (obj: PipelineMetadata) => any;

export declare const GetPipelineOutputFilterSensitiveLog: (obj: GetPipelineOutput) => any;

export declare const GetPipelineExecutionInputFilterSensitiveLog: (obj: GetPipelineExecutionInput) => any;

export declare const PipelineExecutionFilterSensitiveLog: (obj: PipelineExecution) => any;

export declare const GetPipelineExecutionOutputFilterSensitiveLog: (obj: GetPipelineExecutionOutput) => any;

export declare const GetPipelineStateInputFilterSensitiveLog: (obj: GetPipelineStateInput) => any;

export declare const StageExecutionFilterSensitiveLog: (obj: StageExecution) => any;

export declare const TransitionStateFilterSensitiveLog: (obj: TransitionState) => any;

export declare const StageStateFilterSensitiveLog: (obj: StageState) => any;

export declare const GetPipelineStateOutputFilterSensitiveLog: (obj: GetPipelineStateOutput) => any;

export declare const GetThirdPartyJobDetailsInputFilterSensitiveLog: (obj: GetThirdPartyJobDetailsInput) => any;

export declare const ThirdPartyJobDataFilterSensitiveLog: (obj: ThirdPartyJobData) => any;

export declare const ThirdPartyJobDetailsFilterSensitiveLog: (obj: ThirdPartyJobDetails) => any;

export declare const GetThirdPartyJobDetailsOutputFilterSensitiveLog: (obj: GetThirdPartyJobDetailsOutput) => any;

export declare const ListActionExecutionsInputFilterSensitiveLog: (obj: ListActionExecutionsInput) => any;

export declare const ListActionExecutionsOutputFilterSensitiveLog: (obj: ListActionExecutionsOutput) => any;

export declare const ListActionTypesInputFilterSensitiveLog: (obj: ListActionTypesInput) => any;

export declare const ListActionTypesOutputFilterSensitiveLog: (obj: ListActionTypesOutput) => any;

export declare const ListPipelineExecutionsInputFilterSensitiveLog: (obj: ListPipelineExecutionsInput) => any;

export declare const SourceRevisionFilterSensitiveLog: (obj: SourceRevision) => any;

export declare const StopExecutionTriggerFilterSensitiveLog: (obj: StopExecutionTrigger) => any;

export declare const ExecutionTriggerFilterSensitiveLog: (obj: ExecutionTrigger) => any;

export declare const PipelineExecutionSummaryFilterSensitiveLog: (obj: PipelineExecutionSummary) => any;

export declare const ListPipelineExecutionsOutputFilterSensitiveLog: (obj: ListPipelineExecutionsOutput) => any;

export declare const ListPipelinesInputFilterSensitiveLog: (obj: ListPipelinesInput) => any;

export declare const PipelineSummaryFilterSensitiveLog: (obj: PipelineSummary) => any;

export declare const ListPipelinesOutputFilterSensitiveLog: (obj: ListPipelinesOutput) => any;

export declare const ListTagsForResourceInputFilterSensitiveLog: (obj: ListTagsForResourceInput) => any;

export declare const ListTagsForResourceOutputFilterSensitiveLog: (obj: ListTagsForResourceOutput) => any;

export declare const ListWebhooksInputFilterSensitiveLog: (obj: ListWebhooksInput) => any;

export declare const WebhookAuthConfigurationFilterSensitiveLog: (obj: WebhookAuthConfiguration) => any;

export declare const WebhookFilterRuleFilterSensitiveLog: (obj: WebhookFilterRule) => any;

export declare const WebhookDefinitionFilterSensitiveLog: (obj: WebhookDefinition) => any;

export declare const ListWebhookItemFilterSensitiveLog: (obj: ListWebhookItem) => any;

export declare const ListWebhooksOutputFilterSensitiveLog: (obj: ListWebhooksOutput) => any;

export declare const PollForJobsInputFilterSensitiveLog: (obj: PollForJobsInput) => any;

export declare const JobFilterSensitiveLog: (obj: Job) => any;

export declare const PollForJobsOutputFilterSensitiveLog: (obj: PollForJobsOutput) => any;

export declare const PollForThirdPartyJobsInputFilterSensitiveLog: (obj: PollForThirdPartyJobsInput) => any;

export declare const ThirdPartyJobFilterSensitiveLog: (obj: ThirdPartyJob) => any;

export declare const PollForThirdPartyJobsOutputFilterSensitiveLog: (obj: PollForThirdPartyJobsOutput) => any;

export declare const PutActionRevisionInputFilterSensitiveLog: (obj: PutActionRevisionInput) => any;

export declare const PutActionRevisionOutputFilterSensitiveLog: (obj: PutActionRevisionOutput) => any;

export declare const PutApprovalResultInputFilterSensitiveLog: (obj: PutApprovalResultInput) => any;

export declare const PutApprovalResultOutputFilterSensitiveLog: (obj: PutApprovalResultOutput) => any;

export declare const FailureDetailsFilterSensitiveLog: (obj: FailureDetails) => any;

export declare const PutJobFailureResultInputFilterSensitiveLog: (obj: PutJobFailureResultInput) => any;

export declare const CurrentRevisionFilterSensitiveLog: (obj: CurrentRevision) => any;

export declare const ExecutionDetailsFilterSensitiveLog: (obj: ExecutionDetails) => any;

export declare const PutJobSuccessResultInputFilterSensitiveLog: (obj: PutJobSuccessResultInput) => any;

export declare const PutThirdPartyJobFailureResultInputFilterSensitiveLog: (obj: PutThirdPartyJobFailureResultInput) => any;

export declare const PutThirdPartyJobSuccessResultInputFilterSensitiveLog: (obj: PutThirdPartyJobSuccessResultInput) => any;

export declare const PutWebhookInputFilterSensitiveLog: (obj: PutWebhookInput) => any;

export declare const PutWebhookOutputFilterSensitiveLog: (obj: PutWebhookOutput) => any;

export declare const RegisterWebhookWithThirdPartyInputFilterSensitiveLog: (obj: RegisterWebhookWithThirdPartyInput) => any;

export declare const RegisterWebhookWithThirdPartyOutputFilterSensitiveLog: (obj: RegisterWebhookWithThirdPartyOutput) => any;

export declare const RetryStageExecutionInputFilterSensitiveLog: (obj: RetryStageExecutionInput) => any;

export declare const RetryStageExecutionOutputFilterSensitiveLog: (obj: RetryStageExecutionOutput) => any;

export declare const StartPipelineExecutionInputFilterSensitiveLog: (obj: StartPipelineExecutionInput) => any;

export declare const StartPipelineExecutionOutputFilterSensitiveLog: (obj: StartPipelineExecutionOutput) => any;

export declare const StopPipelineExecutionInputFilterSensitiveLog: (obj: StopPipelineExecutionInput) => any;

export declare const StopPipelineExecutionOutputFilterSensitiveLog: (obj: StopPipelineExecutionOutput) => any;

export declare const TagResourceInputFilterSensitiveLog: (obj: TagResourceInput) => any;

export declare const TagResourceOutputFilterSensitiveLog: (obj: TagResourceOutput) => any;

export declare const UntagResourceInputFilterSensitiveLog: (obj: UntagResourceInput) => any;

export declare const UntagResourceOutputFilterSensitiveLog: (obj: UntagResourceOutput) => any;

export declare const UpdateActionTypeInputFilterSensitiveLog: (obj: UpdateActionTypeInput) => any;

export declare const UpdatePipelineInputFilterSensitiveLog: (obj: UpdatePipelineInput) => any;

export declare const UpdatePipelineOutputFilterSensitiveLog: (obj: UpdatePipelineOutput) => any;
