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;
}
