aws-local-stepfunctions 0.4.0 → 0.6.0

package/build/main.d.ts

@@ -1,18 +1,21 @@
-declare type StateType = 'Task' | 'Map' | 'Pass' | 'Wait' | 'Choice' | 'Succeed' | 'Fail';
+import { FromCognitoIdentityPoolParameters } from '@aws-sdk/credential-provider-cognito-identity/dist-types/fromCognitoIdentityPool';
+import { Credentials } from '@aws-sdk/types/dist-types/credentials';
+
+type StateType = 'Task' | 'Parallel' | 'Map' | 'Pass' | 'Wait' | 'Choice' | 'Succeed' | 'Fail';
 
 interface BaseState {
     Type: StateType;
     Comment?: string;
 }
 
-declare type JSONPrimitiveValue = null | boolean | number | string;
-declare type JSONArray = (JSONPrimitiveValue | JSONArray | JSONObject)[];
-declare type JSONObject = {
+type JSONPrimitiveValue = null | boolean | number | string;
+type JSONArray = (JSONPrimitiveValue | JSONArray | JSONObject)[];
+type JSONObject = {
     [key: string]: JSONPrimitiveValue | JSONObject | JSONArray;
 };
-declare type JSONValue = JSONPrimitiveValue | JSONObject | JSONArray;
+type JSONValue = JSONPrimitiveValue | JSONObject | JSONArray;
 
-declare type PayloadTemplate = JSONObject;
+type PayloadTemplate = JSONObject;
 interface CanHaveInputPath {
     InputPath?: string | null;
 }
@@ -29,54 +32,54 @@ interface CanHaveOutputPath {
     OutputPath?: string | null;
 }
 
-declare type StringOperatorNames = 'StringEquals' | 'StringLessThan' | 'StringGreaterThan' | 'StringLessThanEquals' | 'StringGreaterThanEquals' | 'StringMatches';
-declare type StringPathOperatorNames = 'StringEqualsPath' | 'StringLessThanPath' | 'StringGreaterThanPath' | 'StringLessThanEqualsPath' | 'StringGreaterThanEqualsPath';
-declare type NumericOperatorNames = 'NumericEquals' | 'NumericLessThan' | 'NumericGreaterThan' | 'NumericLessThanEquals' | 'NumericGreaterThanEquals';
-declare type NumericPathOperatorNames = 'NumericEqualsPath' | 'NumericLessThanPath' | 'NumericGreaterThanPath' | 'NumericLessThanEqualsPath' | 'NumericGreaterThanEqualsPath';
-declare type BooleanOperatorNames = 'BooleanEquals';
-declare type BooleanPathOperatorNames = 'BooleanEqualsPath';
-declare type TimestampOperatorNames = 'TimestampEquals' | 'TimestampLessThan' | 'TimestampGreaterThan' | 'TimestampLessThanEquals' | 'TimestampGreaterThanEquals';
-declare type TimestampPathOperatorNames = 'TimestampEqualsPath' | 'TimestampLessThanPath' | 'TimestampGreaterThanPath' | 'TimestampLessThanEqualsPath' | 'TimestampGreaterThanEqualsPath';
-declare type TypeTestOperatorNames = 'IsNull' | 'IsPresent' | 'IsNumeric' | 'IsString' | 'IsBoolean' | 'IsTimestamp';
-declare type StringComparisonOperator = {
+type StringOperatorNames = 'StringEquals' | 'StringLessThan' | 'StringGreaterThan' | 'StringLessThanEquals' | 'StringGreaterThanEquals' | 'StringMatches';
+type StringPathOperatorNames = 'StringEqualsPath' | 'StringLessThanPath' | 'StringGreaterThanPath' | 'StringLessThanEqualsPath' | 'StringGreaterThanEqualsPath';
+type NumericOperatorNames = 'NumericEquals' | 'NumericLessThan' | 'NumericGreaterThan' | 'NumericLessThanEquals' | 'NumericGreaterThanEquals';
+type NumericPathOperatorNames = 'NumericEqualsPath' | 'NumericLessThanPath' | 'NumericGreaterThanPath' | 'NumericLessThanEqualsPath' | 'NumericGreaterThanEqualsPath';
+type BooleanOperatorNames = 'BooleanEquals';
+type BooleanPathOperatorNames = 'BooleanEqualsPath';
+type TimestampOperatorNames = 'TimestampEquals' | 'TimestampLessThan' | 'TimestampGreaterThan' | 'TimestampLessThanEquals' | 'TimestampGreaterThanEquals';
+type TimestampPathOperatorNames = 'TimestampEqualsPath' | 'TimestampLessThanPath' | 'TimestampGreaterThanPath' | 'TimestampLessThanEqualsPath' | 'TimestampGreaterThanEqualsPath';
+type TypeTestOperatorNames = 'IsNull' | 'IsPresent' | 'IsNumeric' | 'IsString' | 'IsBoolean' | 'IsTimestamp';
+type StringComparisonOperator = {
     [P in StringOperatorNames]?: string;
 };
-declare type StringPathComparisonOperator = {
+type StringPathComparisonOperator = {
     [P in StringPathOperatorNames]?: string;
 };
-declare type NumericComparisonOperator = {
+type NumericComparisonOperator = {
     [P in NumericOperatorNames]?: number;
 };
-declare type NumericPathComparisonOperator = {
+type NumericPathComparisonOperator = {
     [P in NumericPathOperatorNames]?: string;
 };
-declare type BooleanComparisonOperator = {
+type BooleanComparisonOperator = {
     [P in BooleanOperatorNames]?: boolean;
 };
-declare type BooleanPathComparisonOperator = {
+type BooleanPathComparisonOperator = {
     [P in BooleanPathOperatorNames]?: string;
 };
-declare type TimestampComparisonOperator = {
+type TimestampComparisonOperator = {
     [P in TimestampOperatorNames]?: string;
 };
-declare type TimestampPathComparisonOperator = {
+type TimestampPathComparisonOperator = {
     [P in TimestampPathOperatorNames]?: string;
 };
-declare type TypeTestComparisonOperator = {
+type TypeTestComparisonOperator = {
     [P in TypeTestOperatorNames]?: true;
 };
-declare type ComparisonOperator = StringComparisonOperator | StringPathComparisonOperator | NumericComparisonOperator | NumericPathComparisonOperator | BooleanComparisonOperator | BooleanPathComparisonOperator | TimestampComparisonOperator | TimestampPathComparisonOperator | TypeTestComparisonOperator;
-declare type BaseDataTestExpression = {
+type ComparisonOperator = StringComparisonOperator | StringPathComparisonOperator | NumericComparisonOperator | NumericPathComparisonOperator | BooleanComparisonOperator | BooleanPathComparisonOperator | TimestampComparisonOperator | TimestampPathComparisonOperator | TypeTestComparisonOperator;
+type BaseDataTestExpression = {
     Variable: string;
 };
-declare type DataTestExpression = BaseDataTestExpression & ComparisonOperator;
-declare type BooleanExpression = {
+type DataTestExpression = BaseDataTestExpression & ComparisonOperator;
+type BooleanExpression = {
     And?: ChoiceRuleWithoutNext[];
     Or?: ChoiceRuleWithoutNext[];
     Not?: ChoiceRuleWithoutNext;
 };
-declare type ChoiceRuleWithoutNext = DataTestExpression | BooleanExpression;
-declare type ChoiceRule = (DataTestExpression | BooleanExpression) & {
+type ChoiceRuleWithoutNext = DataTestExpression | BooleanExpression;
+type ChoiceRule = (DataTestExpression | BooleanExpression) & {
     Next: string;
 };
 interface BaseChoiceState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
@@ -84,7 +87,7 @@ interface BaseChoiceState extends BaseState, CanHaveInputPath, CanHaveOutputPath
     Choices: ChoiceRule[];
     Default?: string;
 }
-declare type ChoiceState = BaseChoiceState;
+type ChoiceState = BaseChoiceState;
 
 interface EndableState extends BaseState {
     Type: Exclude<StateType, 'Choice' | 'Succeed' | 'Fail'>;
@@ -93,16 +96,16 @@ interface EndableState extends BaseState {
 interface SucceedOrFailState extends BaseState {
     Type: Extract<StateType, 'Succeed' | 'Fail'>;
 }
-declare type TerminalState = EndableState | SucceedOrFailState;
+type TerminalState = EndableState | SucceedOrFailState;
 
 interface BaseFailState extends BaseState {
     Type: 'Fail';
     Cause?: string;
     Error?: string;
 }
-declare type FailState = TerminalState & BaseFailState;
+type FailState = TerminalState & BaseFailState;
 
-declare type Retrier = {
+type Retrier = {
     ErrorEquals: string[];
     IntervalSeconds?: number;
     MaxAttempts?: number;
@@ -111,7 +114,7 @@ declare type Retrier = {
 interface RetryableState {
     Retry?: Retrier[];
 }
-declare type Catcher = {
+type Catcher = {
     ErrorEquals: string[];
     Next: string;
     ResultPath?: string;
@@ -124,7 +127,7 @@ interface NextableState extends BaseState {
     Type: Exclude<StateType, 'Choice' | 'Succeed' | 'Fail'>;
     Next: string;
 }
-declare type IntermediateState = NextableState;
+type IntermediateState = NextableState;
 
 interface BaseMapState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath, RetryableState, CatchableState {
     Type: 'Map';
@@ -132,24 +135,30 @@ interface BaseMapState extends BaseState, CanHaveInputPath, CanHaveParameters, C
     ItemsPath?: string;
     MaxConcurrency?: number;
 }
-declare type MapState = (IntermediateState | TerminalState) & BaseMapState;
+type MapState = (IntermediateState | TerminalState) & BaseMapState;
+
+interface BaseParallelState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath, RetryableState, CatchableState {
+    Type: 'Parallel';
+    Branches: Omit<StateMachineDefinition, 'Version' | 'TimeoutSeconds'>[];
+}
+type ParallelState = (IntermediateState | TerminalState) & BaseParallelState;
 
 interface BasePassState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultPath, CanHaveOutputPath {
     Type: 'Pass';
     Result?: JSONValue;
 }
-declare type PassState = (IntermediateState | TerminalState) & BasePassState;
+type PassState = (IntermediateState | TerminalState) & BasePassState;
 
 interface BaseSucceedState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
     Type: 'Succeed';
 }
-declare type SucceedState = TerminalState & BaseSucceedState;
+type SucceedState = TerminalState & BaseSucceedState;
 
 interface BaseTaskState extends BaseState, CanHaveInputPath, CanHaveParameters, CanHaveResultSelector, CanHaveResultPath, CanHaveOutputPath, RetryableState, CatchableState {
     Type: 'Task';
     Resource: string;
 }
-declare type TaskState = (IntermediateState | TerminalState) & BaseTaskState;
+type TaskState = (IntermediateState | TerminalState) & BaseTaskState;
 
 interface BaseWaitState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
     Type: 'Wait';
@@ -158,9 +167,9 @@ interface BaseWaitState extends BaseState, CanHaveInputPath, CanHaveOutputPath {
     SecondsPath?: string;
     TimestampPath?: string;
 }
-declare type WaitState = (IntermediateState | TerminalState) & BaseWaitState;
+type WaitState = (IntermediateState | TerminalState) & BaseWaitState;
 
-declare type AllStates = TaskState | MapState | PassState | WaitState | ChoiceState | SucceedState | FailState;
+type AllStates = TaskState | ParallelState | MapState | PassState | WaitState | ChoiceState | SucceedState | FailState;
 
 interface StateMachineDefinition {
     States: Record<string, AllStates>;
@@ -170,10 +179,10 @@ interface StateMachineDefinition {
     TimeoutSeconds?: number;
 }
 
-declare type TaskStateResourceLocalHandler = {
+type TaskStateResourceLocalHandler = {
     [taskStateName: string]: (input: JSONValue) => Promise<JSONValue>;
 };
-declare type WaitStateTimeOverride = {
+type WaitStateTimeOverride = {
     [waitStateName: string]: number;
 };
 interface Overrides {
@@ -184,6 +193,17 @@ interface ValidationOptions {
     readonly checkPaths?: boolean;
     readonly checkArn?: boolean;
 }
+interface AWSConfig {
+    region: string;
+    credentials?: {
+        cognitoIdentityPool?: FromCognitoIdentityPoolParameters;
+        accessKeys?: Omit<Credentials, 'expiration'>;
+    };
+}
+interface StateMachineOptions {
+    validationOptions?: ValidationOptions;
+    awsConfig?: AWSConfig;
+}
 interface RunOptions {
     overrides?: Overrides;
     noThrowOnAbort?: boolean;
@@ -195,16 +215,16 @@ declare class StateMachine {
      */
     private readonly definition;
     /**
-     * Options to control whether to apply certain validations to the state machine definition.
+     * Options to control certain settings of the state machine.
      */
-    private readonly validationOptions;
+    private readonly stateMachineOptions;
     /**
      * Constructs a new state machine.
      * @param definition The state machine definition defined using the Amazon States Language (https://states-language.net/spec.html).
-     * @param validationOptions Options to control whether to apply certain validations to the definition.
-     * These options also apply to state machines defined in  the `Iterator` field of `Map` states.
+     * @param stateMachineOptions Options to control certain settings of the state machine.
+     * These options also apply to state machines defined in the `Iterator` field of `Map` states and in the `Branches` field of `Parallel` states.
      */
-    constructor(definition: StateMachineDefinition, validationOptions?: ValidationOptions);
+    constructor(definition: StateMachineDefinition, stateMachineOptions?: StateMachineOptions);
     /**
      * Executes the state machine, running through the states specified in the definition.
      * If the execution fails, the result will throw an `ExecutionError` explaining why the
@@ -242,4 +262,25 @@ declare class ExecutionAbortedError extends Error {
     constructor();
 }
 
-export { ExecutionAbortedError, ExecutionError, StateMachine };
+/**
+ * Base class for all internal errors that can be thrown during the state machine execution.
+ */
+declare class RuntimeError extends Error {
+    /**
+     * Whether this runtime error can be matched in a `Retry` field
+     */
+    protected retryable: boolean;
+    /**
+     * Whether this runtime error can be caught in a `Catch` field
+     */
+    protected catchable: boolean;
+    constructor(message: string);
+    get isRetryable(): boolean;
+    get isCatchable(): boolean;
+}
+
+declare class StatesTimeoutError extends RuntimeError {
+    constructor();
+}
+
+export { ExecutionAbortedError, ExecutionError, StatesTimeoutError as ExecutionTimeoutError, StateMachine };