@aws-sdk/client-sfn 3.934.0 → 3.935.0

package/dist-types/schemas/schemas_0.d.ts

@@ -3,10 +3,16 @@ export declare var AliasDescription: StaticSimpleSchema;
 export declare var ConnectorParameters: StaticSimpleSchema;
 export declare var Definition: StaticSimpleSchema;
 export declare var EvaluationFailureLocation: StaticSimpleSchema;
+export declare var ExceptionHandlerIndex: StaticSimpleSchema;
+export declare var InspectionMaxConcurrency: StaticSimpleSchema;
+export declare var InspectionToleratedFailureCount: StaticSimpleSchema;
+export declare var InspectionToleratedFailurePercentage: StaticSimpleSchema;
+export declare var RetryBackoffIntervalSeconds: StaticSimpleSchema;
 export declare var SensitiveCause: StaticSimpleSchema;
 export declare var SensitiveData: StaticSimpleSchema;
 export declare var SensitiveDataJobInput: StaticSimpleSchema;
 export declare var SensitiveError: StaticSimpleSchema;
+export declare var TestStateStateName: StaticSimpleSchema;
 export declare var ValidateStateMachineDefinitionCode: StaticSimpleSchema;
 export declare var ValidateStateMachineDefinitionLocation: StaticSimpleSchema;
 export declare var ValidateStateMachineDefinitionMessage: StaticSimpleSchema;
@@ -77,6 +83,7 @@ export declare var HistoryEventExecutionDataDetails: StaticStructureSchema;
 export declare var InspectionData: StaticStructureSchema;
 export declare var InspectionDataRequest: StaticStructureSchema;
 export declare var InspectionDataResponse: StaticStructureSchema;
+export declare var InspectionErrorDetails: StaticStructureSchema;
 export declare var InvalidArn: StaticErrorSchema;
 export declare var InvalidDefinition: StaticErrorSchema;
 export declare var InvalidEncryptionConfiguration: StaticErrorSchema;
@@ -120,6 +127,8 @@ export declare var MapRunRedrivenEventDetails: StaticStructureSchema;
 export declare var MapRunStartedEventDetails: StaticStructureSchema;
 export declare var MapStateStartedEventDetails: StaticStructureSchema;
 export declare var MissingRequiredParameter: StaticErrorSchema;
+export declare var MockErrorOutput: StaticStructureSchema;
+export declare var MockInput: StaticStructureSchema;
 export declare var PublishStateMachineVersionInput: StaticStructureSchema;
 export declare var PublishStateMachineVersionOutput: StaticStructureSchema;
 export declare var RedriveExecutionInput: StaticStructureSchema;
@@ -163,6 +172,7 @@ export declare var TaskSubmittedEventDetails: StaticStructureSchema;
 export declare var TaskSucceededEventDetails: StaticStructureSchema;
 export declare var TaskTimedOut: StaticErrorSchema;
 export declare var TaskTimedOutEventDetails: StaticStructureSchema;
+export declare var TestStateConfiguration: StaticStructureSchema;
 export declare var TestStateInput: StaticStructureSchema;
 export declare var TestStateOutput: StaticStructureSchema;
 export declare var TooManyTags: StaticErrorSchema;

package/dist-types/ts3.4/index.d.ts

@@ -5,5 +5,7 @@ export { RuntimeExtension } from "./runtimeExtensions";
 export { SFNExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
-export * from "./models";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
 export { SFNServiceException } from "./models/SFNServiceException";

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

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

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

@@ -0,0 +1,218 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { KmsKeyState, ValidationExceptionReason } from "./enums";
+import { SFNServiceException as __BaseException } from "./SFNServiceException";
+export declare class ActivityAlreadyExists extends __BaseException {
+  readonly name: "ActivityAlreadyExists";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ActivityAlreadyExists, __BaseException>
+  );
+}
+export declare class ActivityDoesNotExist extends __BaseException {
+  readonly name: "ActivityDoesNotExist";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ActivityDoesNotExist, __BaseException>
+  );
+}
+export declare class ActivityLimitExceeded extends __BaseException {
+  readonly name: "ActivityLimitExceeded";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ActivityLimitExceeded, __BaseException>
+  );
+}
+export declare class ActivityWorkerLimitExceeded extends __BaseException {
+  readonly name: "ActivityWorkerLimitExceeded";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ActivityWorkerLimitExceeded, __BaseException>
+  );
+}
+export declare class InvalidEncryptionConfiguration extends __BaseException {
+  readonly name: "InvalidEncryptionConfiguration";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<InvalidEncryptionConfiguration, __BaseException>
+  );
+}
+export declare class InvalidName extends __BaseException {
+  readonly name: "InvalidName";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<InvalidName, __BaseException>);
+}
+export declare class KmsAccessDeniedException extends __BaseException {
+  readonly name: "KmsAccessDeniedException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<KmsAccessDeniedException, __BaseException>
+  );
+}
+export declare class KmsThrottlingException extends __BaseException {
+  readonly name: "KmsThrottlingException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<KmsThrottlingException, __BaseException>
+  );
+}
+export declare class TooManyTags extends __BaseException {
+  readonly name: "TooManyTags";
+  readonly $fault: "client";
+  resourceName?: string | undefined;
+  constructor(opts: __ExceptionOptionType<TooManyTags, __BaseException>);
+}
+export declare class ConflictException extends __BaseException {
+  readonly name: "ConflictException";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+export declare class InvalidArn extends __BaseException {
+  readonly name: "InvalidArn";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<InvalidArn, __BaseException>);
+}
+export declare class InvalidDefinition extends __BaseException {
+  readonly name: "InvalidDefinition";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<InvalidDefinition, __BaseException>);
+}
+export declare class InvalidLoggingConfiguration extends __BaseException {
+  readonly name: "InvalidLoggingConfiguration";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<InvalidLoggingConfiguration, __BaseException>
+  );
+}
+export declare class InvalidTracingConfiguration extends __BaseException {
+  readonly name: "InvalidTracingConfiguration";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<InvalidTracingConfiguration, __BaseException>
+  );
+}
+export declare class StateMachineAlreadyExists extends __BaseException {
+  readonly name: "StateMachineAlreadyExists";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<StateMachineAlreadyExists, __BaseException>
+  );
+}
+export declare class StateMachineDeleting extends __BaseException {
+  readonly name: "StateMachineDeleting";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<StateMachineDeleting, __BaseException>
+  );
+}
+export declare class StateMachineLimitExceeded extends __BaseException {
+  readonly name: "StateMachineLimitExceeded";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<StateMachineLimitExceeded, __BaseException>
+  );
+}
+export declare class StateMachineTypeNotSupported extends __BaseException {
+  readonly name: "StateMachineTypeNotSupported";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<StateMachineTypeNotSupported, __BaseException>
+  );
+}
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  reason?: ValidationExceptionReason | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export declare class ResourceNotFound extends __BaseException {
+  readonly name: "ResourceNotFound";
+  readonly $fault: "client";
+  resourceName?: string | undefined;
+  constructor(opts: __ExceptionOptionType<ResourceNotFound, __BaseException>);
+}
+export declare class ServiceQuotaExceededException extends __BaseException {
+  readonly name: "ServiceQuotaExceededException";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>
+  );
+}
+export declare class ExecutionDoesNotExist extends __BaseException {
+  readonly name: "ExecutionDoesNotExist";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ExecutionDoesNotExist, __BaseException>
+  );
+}
+export declare class KmsInvalidStateException extends __BaseException {
+  readonly name: "KmsInvalidStateException";
+  readonly $fault: "client";
+  kmsKeyState?: KmsKeyState | undefined;
+  constructor(
+    opts: __ExceptionOptionType<KmsInvalidStateException, __BaseException>
+  );
+}
+export declare class StateMachineDoesNotExist extends __BaseException {
+  readonly name: "StateMachineDoesNotExist";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<StateMachineDoesNotExist, __BaseException>
+  );
+}
+export declare class InvalidToken extends __BaseException {
+  readonly name: "InvalidToken";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<InvalidToken, __BaseException>);
+}
+export declare class ExecutionLimitExceeded extends __BaseException {
+  readonly name: "ExecutionLimitExceeded";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ExecutionLimitExceeded, __BaseException>
+  );
+}
+export declare class ExecutionNotRedrivable extends __BaseException {
+  readonly name: "ExecutionNotRedrivable";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ExecutionNotRedrivable, __BaseException>
+  );
+}
+export declare class TaskDoesNotExist extends __BaseException {
+  readonly name: "TaskDoesNotExist";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<TaskDoesNotExist, __BaseException>);
+}
+export declare class TaskTimedOut extends __BaseException {
+  readonly name: "TaskTimedOut";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<TaskTimedOut, __BaseException>);
+}
+export declare class InvalidOutput extends __BaseException {
+  readonly name: "InvalidOutput";
+  readonly $fault: "client";
+  constructor(opts: __ExceptionOptionType<InvalidOutput, __BaseException>);
+}
+export declare class ExecutionAlreadyExists extends __BaseException {
+  readonly name: "ExecutionAlreadyExists";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<ExecutionAlreadyExists, __BaseException>
+  );
+}
+export declare class InvalidExecutionInput extends __BaseException {
+  readonly name: "InvalidExecutionInput";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<InvalidExecutionInput, __BaseException>
+  );
+}
+export declare class MissingRequiredParameter extends __BaseException {
+  readonly name: "MissingRequiredParameter";
+  readonly $fault: "client";
+  constructor(
+    opts: __ExceptionOptionType<MissingRequiredParameter, __BaseException>
+  );
+}