@aws-sdk/client-sfn 3.933.0 → 3.935.0

package/dist-es/models/enums.js

@@ -0,0 +1,151 @@
+export const EncryptionType = {
+    AWS_OWNED_KEY: "AWS_OWNED_KEY",
+    CUSTOMER_MANAGED_KMS_KEY: "CUSTOMER_MANAGED_KMS_KEY",
+};
+export const LogLevel = {
+    ALL: "ALL",
+    ERROR: "ERROR",
+    FATAL: "FATAL",
+    OFF: "OFF",
+};
+export const StateMachineType = {
+    EXPRESS: "EXPRESS",
+    STANDARD: "STANDARD",
+};
+export const ValidationExceptionReason = {
+    API_DOES_NOT_SUPPORT_LABELED_ARNS: "API_DOES_NOT_SUPPORT_LABELED_ARNS",
+    CANNOT_UPDATE_COMPLETED_MAP_RUN: "CANNOT_UPDATE_COMPLETED_MAP_RUN",
+    INVALID_ROUTING_CONFIGURATION: "INVALID_ROUTING_CONFIGURATION",
+    MISSING_REQUIRED_PARAMETER: "MISSING_REQUIRED_PARAMETER",
+};
+export const IncludedData = {
+    ALL_DATA: "ALL_DATA",
+    METADATA_ONLY: "METADATA_ONLY",
+};
+export const ExecutionRedriveStatus = {
+    NOT_REDRIVABLE: "NOT_REDRIVABLE",
+    REDRIVABLE: "REDRIVABLE",
+    REDRIVABLE_BY_MAP_RUN: "REDRIVABLE_BY_MAP_RUN",
+};
+export const ExecutionStatus = {
+    ABORTED: "ABORTED",
+    FAILED: "FAILED",
+    PENDING_REDRIVE: "PENDING_REDRIVE",
+    RUNNING: "RUNNING",
+    SUCCEEDED: "SUCCEEDED",
+    TIMED_OUT: "TIMED_OUT",
+};
+export const KmsKeyState = {
+    CREATING: "CREATING",
+    DISABLED: "DISABLED",
+    PENDING_DELETION: "PENDING_DELETION",
+    PENDING_IMPORT: "PENDING_IMPORT",
+    UNAVAILABLE: "UNAVAILABLE",
+};
+export const MapRunStatus = {
+    ABORTED: "ABORTED",
+    FAILED: "FAILED",
+    RUNNING: "RUNNING",
+    SUCCEEDED: "SUCCEEDED",
+};
+export const StateMachineStatus = {
+    ACTIVE: "ACTIVE",
+    DELETING: "DELETING",
+};
+export const HistoryEventType = {
+    ActivityFailed: "ActivityFailed",
+    ActivityScheduleFailed: "ActivityScheduleFailed",
+    ActivityScheduled: "ActivityScheduled",
+    ActivityStarted: "ActivityStarted",
+    ActivitySucceeded: "ActivitySucceeded",
+    ActivityTimedOut: "ActivityTimedOut",
+    ChoiceStateEntered: "ChoiceStateEntered",
+    ChoiceStateExited: "ChoiceStateExited",
+    EvaluationFailed: "EvaluationFailed",
+    ExecutionAborted: "ExecutionAborted",
+    ExecutionFailed: "ExecutionFailed",
+    ExecutionRedriven: "ExecutionRedriven",
+    ExecutionStarted: "ExecutionStarted",
+    ExecutionSucceeded: "ExecutionSucceeded",
+    ExecutionTimedOut: "ExecutionTimedOut",
+    FailStateEntered: "FailStateEntered",
+    LambdaFunctionFailed: "LambdaFunctionFailed",
+    LambdaFunctionScheduleFailed: "LambdaFunctionScheduleFailed",
+    LambdaFunctionScheduled: "LambdaFunctionScheduled",
+    LambdaFunctionStartFailed: "LambdaFunctionStartFailed",
+    LambdaFunctionStarted: "LambdaFunctionStarted",
+    LambdaFunctionSucceeded: "LambdaFunctionSucceeded",
+    LambdaFunctionTimedOut: "LambdaFunctionTimedOut",
+    MapIterationAborted: "MapIterationAborted",
+    MapIterationFailed: "MapIterationFailed",
+    MapIterationStarted: "MapIterationStarted",
+    MapIterationSucceeded: "MapIterationSucceeded",
+    MapRunAborted: "MapRunAborted",
+    MapRunFailed: "MapRunFailed",
+    MapRunRedriven: "MapRunRedriven",
+    MapRunStarted: "MapRunStarted",
+    MapRunSucceeded: "MapRunSucceeded",
+    MapStateAborted: "MapStateAborted",
+    MapStateEntered: "MapStateEntered",
+    MapStateExited: "MapStateExited",
+    MapStateFailed: "MapStateFailed",
+    MapStateStarted: "MapStateStarted",
+    MapStateSucceeded: "MapStateSucceeded",
+    ParallelStateAborted: "ParallelStateAborted",
+    ParallelStateEntered: "ParallelStateEntered",
+    ParallelStateExited: "ParallelStateExited",
+    ParallelStateFailed: "ParallelStateFailed",
+    ParallelStateStarted: "ParallelStateStarted",
+    ParallelStateSucceeded: "ParallelStateSucceeded",
+    PassStateEntered: "PassStateEntered",
+    PassStateExited: "PassStateExited",
+    SucceedStateEntered: "SucceedStateEntered",
+    SucceedStateExited: "SucceedStateExited",
+    TaskFailed: "TaskFailed",
+    TaskScheduled: "TaskScheduled",
+    TaskStartFailed: "TaskStartFailed",
+    TaskStarted: "TaskStarted",
+    TaskStateAborted: "TaskStateAborted",
+    TaskStateEntered: "TaskStateEntered",
+    TaskStateExited: "TaskStateExited",
+    TaskSubmitFailed: "TaskSubmitFailed",
+    TaskSubmitted: "TaskSubmitted",
+    TaskSucceeded: "TaskSucceeded",
+    TaskTimedOut: "TaskTimedOut",
+    WaitStateAborted: "WaitStateAborted",
+    WaitStateEntered: "WaitStateEntered",
+    WaitStateExited: "WaitStateExited",
+};
+export const ExecutionRedriveFilter = {
+    NOT_REDRIVEN: "NOT_REDRIVEN",
+    REDRIVEN: "REDRIVEN",
+};
+export const SyncExecutionStatus = {
+    FAILED: "FAILED",
+    SUCCEEDED: "SUCCEEDED",
+    TIMED_OUT: "TIMED_OUT",
+};
+export const InspectionLevel = {
+    DEBUG: "DEBUG",
+    INFO: "INFO",
+    TRACE: "TRACE",
+};
+export const MockResponseValidationMode = {
+    NONE: "NONE",
+    PRESENT: "PRESENT",
+    STRICT: "STRICT",
+};
+export const TestExecutionStatus = {
+    CAUGHT_ERROR: "CAUGHT_ERROR",
+    FAILED: "FAILED",
+    RETRIABLE: "RETRIABLE",
+    SUCCEEDED: "SUCCEEDED",
+};
+export const ValidateStateMachineDefinitionSeverity = {
+    ERROR: "ERROR",
+    WARNING: "WARNING",
+};
+export const ValidateStateMachineDefinitionResultCode = {
+    FAIL: "FAIL",
+    OK: "OK",
+};

package/dist-es/models/errors.js

@@ -0,0 +1,405 @@
+import { SFNServiceException as __BaseException } from "./SFNServiceException";
+export class ActivityAlreadyExists extends __BaseException {
+    name = "ActivityAlreadyExists";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityAlreadyExists",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityAlreadyExists.prototype);
+    }
+}
+export class ActivityDoesNotExist extends __BaseException {
+    name = "ActivityDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityDoesNotExist.prototype);
+    }
+}
+export class ActivityLimitExceeded extends __BaseException {
+    name = "ActivityLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityLimitExceeded.prototype);
+    }
+}
+export class ActivityWorkerLimitExceeded extends __BaseException {
+    name = "ActivityWorkerLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityWorkerLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityWorkerLimitExceeded.prototype);
+    }
+}
+export class InvalidEncryptionConfiguration extends __BaseException {
+    name = "InvalidEncryptionConfiguration";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidEncryptionConfiguration",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidEncryptionConfiguration.prototype);
+    }
+}
+export class InvalidName extends __BaseException {
+    name = "InvalidName";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidName",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidName.prototype);
+    }
+}
+export class KmsAccessDeniedException extends __BaseException {
+    name = "KmsAccessDeniedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KmsAccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsAccessDeniedException.prototype);
+    }
+}
+export class KmsThrottlingException extends __BaseException {
+    name = "KmsThrottlingException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KmsThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsThrottlingException.prototype);
+    }
+}
+export class TooManyTags extends __BaseException {
+    name = "TooManyTags";
+    $fault = "client";
+    resourceName;
+    constructor(opts) {
+        super({
+            name: "TooManyTags",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTags.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+export class ConflictException extends __BaseException {
+    name = "ConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+export class InvalidArn extends __BaseException {
+    name = "InvalidArn";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArn",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArn.prototype);
+    }
+}
+export class InvalidDefinition extends __BaseException {
+    name = "InvalidDefinition";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDefinition",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDefinition.prototype);
+    }
+}
+export class InvalidLoggingConfiguration extends __BaseException {
+    name = "InvalidLoggingConfiguration";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLoggingConfiguration",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLoggingConfiguration.prototype);
+    }
+}
+export class InvalidTracingConfiguration extends __BaseException {
+    name = "InvalidTracingConfiguration";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTracingConfiguration",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTracingConfiguration.prototype);
+    }
+}
+export class StateMachineAlreadyExists extends __BaseException {
+    name = "StateMachineAlreadyExists";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineAlreadyExists",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineAlreadyExists.prototype);
+    }
+}
+export class StateMachineDeleting extends __BaseException {
+    name = "StateMachineDeleting";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineDeleting",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineDeleting.prototype);
+    }
+}
+export class StateMachineLimitExceeded extends __BaseException {
+    name = "StateMachineLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineLimitExceeded.prototype);
+    }
+}
+export class StateMachineTypeNotSupported extends __BaseException {
+    name = "StateMachineTypeNotSupported";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineTypeNotSupported",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineTypeNotSupported.prototype);
+    }
+}
+export class ValidationException extends __BaseException {
+    name = "ValidationException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+    }
+}
+export class ResourceNotFound extends __BaseException {
+    name = "ResourceNotFound";
+    $fault = "client";
+    resourceName;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFound",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFound.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export class ExecutionDoesNotExist extends __BaseException {
+    name = "ExecutionDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionDoesNotExist.prototype);
+    }
+}
+export class KmsInvalidStateException extends __BaseException {
+    name = "KmsInvalidStateException";
+    $fault = "client";
+    kmsKeyState;
+    constructor(opts) {
+        super({
+            name: "KmsInvalidStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsInvalidStateException.prototype);
+        this.kmsKeyState = opts.kmsKeyState;
+    }
+}
+export class StateMachineDoesNotExist extends __BaseException {
+    name = "StateMachineDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineDoesNotExist.prototype);
+    }
+}
+export class InvalidToken extends __BaseException {
+    name = "InvalidToken";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidToken",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidToken.prototype);
+    }
+}
+export class ExecutionLimitExceeded extends __BaseException {
+    name = "ExecutionLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionLimitExceeded.prototype);
+    }
+}
+export class ExecutionNotRedrivable extends __BaseException {
+    name = "ExecutionNotRedrivable";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionNotRedrivable",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionNotRedrivable.prototype);
+    }
+}
+export class TaskDoesNotExist extends __BaseException {
+    name = "TaskDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TaskDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TaskDoesNotExist.prototype);
+    }
+}
+export class TaskTimedOut extends __BaseException {
+    name = "TaskTimedOut";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TaskTimedOut",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TaskTimedOut.prototype);
+    }
+}
+export class InvalidOutput extends __BaseException {
+    name = "InvalidOutput";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidOutput",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidOutput.prototype);
+    }
+}
+export class ExecutionAlreadyExists extends __BaseException {
+    name = "ExecutionAlreadyExists";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionAlreadyExists",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionAlreadyExists.prototype);
+    }
+}
+export class InvalidExecutionInput extends __BaseException {
+    name = "InvalidExecutionInput";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidExecutionInput",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidExecutionInput.prototype);
+    }
+}
+export class MissingRequiredParameter extends __BaseException {
+    name = "MissingRequiredParameter";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MissingRequiredParameter",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MissingRequiredParameter.prototype);
+    }
+}