agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/choice.d.ts

@@ -0,0 +1,90 @@
+import type { Construct } from 'constructs';
+import type { AssignableStateOptions, ChoiceTransitionOptions, JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import { Chain } from '../chain';
+import type { Condition } from '../condition';
+import type { IChainable, INextable } from '../types';
+import { QueryLanguage } from '../types';
+/**
+ * Properties for defining a Choice state that using JSONPath
+ */
+export interface ChoiceJsonPathProps extends StateBaseProps, AssignableStateOptions, JsonPathCommonOptions {
+}
+/**
+ * Properties for defining a Choice state that using JSONata
+ */
+export interface ChoiceJsonataProps extends StateBaseProps, AssignableStateOptions, JsonataCommonOptions {
+}
+/**
+ * Properties for defining a Choice state
+ */
+export interface ChoiceProps extends StateBaseProps, AssignableStateOptions, JsonPathCommonOptions, JsonataCommonOptions {
+}
+/**
+ * Define a Choice in the state machine
+ *
+ * A choice state can be used to make decisions based on the execution
+ * state.
+ */
+export declare class Choice extends State {
+    /**
+     * Define a Choice using JSONPath in the state machine
+     *
+     * A choice state can be used to make decisions based on the execution
+     * state.
+     */
+    static jsonPath(scope: Construct, id: string, props?: ChoiceJsonPathProps): Choice;
+    /**
+     * Define a Choice using JSONata in the state machine
+     *
+     * A choice state can be used to make decisions based on the execution
+     * state.
+     */
+    static jsonata(scope: Construct, id: string, props?: ChoiceJsonataProps): Choice;
+    readonly endStates: INextable[];
+    constructor(scope: Construct, id: string, props?: ChoiceProps);
+    /**
+     * If the given condition matches, continue execution with the given state
+     */
+    when(condition: Condition, next: IChainable, options?: ChoiceTransitionOptions): Choice;
+    /**
+     * If none of the given conditions match, continue execution with the given state
+     *
+     * If no conditions match and no otherwise() has been given, an execution
+     * error will be raised.
+     */
+    otherwise(def: IChainable): Choice;
+    /**
+     * Return a Chain that contains all reachable end states from this Choice
+     *
+     * Use this to combine all possible choice paths back.
+     */
+    afterwards(options?: AfterwardsOptions): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(topLevelQueryLanguage?: QueryLanguage): object;
+}
+/**
+ * Options for selecting the choice paths
+ */
+export interface AfterwardsOptions {
+    /**
+     * Whether to include error handling states
+     *
+     * If this is true, all states which are error handlers (added through 'onError')
+     * and states reachable via error handlers will be included as well.
+     *
+     * @default false
+     */
+    readonly includeErrorHandlers?: boolean;
+    /**
+     * Whether to include the default/otherwise transition for the current Choice state
+     *
+     * If this is true and the current Choice does not have a default outgoing
+     * transition, one will be added included when .next() is called on the chain.
+     *
+     * @default false
+     */
+    readonly includeOtherwise?: boolean;
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/choice.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Choice=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},core_1=()=>{var tmp=require("../../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp},chain_1=()=>{var tmp=require("../chain");return chain_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class Choice extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Choice",version:"2.252.0"};static jsonPath(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ChoiceJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Choice(scope,id,props)}static jsonata(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ChoiceJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Choice(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}endStates=[];constructor(scope,id,props={}){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ChoiceProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Choice),error}}when(condition,next,options){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_Condition(condition),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(next),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ChoiceTransitionOptions(options)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.when),error}return super.addChoice(condition,next.startState,options),this}otherwise(def){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(def)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.otherwise),error}return super.makeDefault(def.startState),this}afterwards(options={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_AfterwardsOptions(options)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.afterwards),error}const endStates=state_1().State.filterNextables(state_1().State.findReachableEndStates(this,{includeErrorHandlers:options.includeErrorHandlers}));if(options.includeOtherwise&&this.defaultChoice)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`ChoiceStateAlreadyHasOtherwise`,`'includeOtherwise' set but Choice state ${this.stateId} already has an 'otherwise' transition`);return options.includeOtherwise&&endStates.push(new DefaultAsNext(this)),chain_1().Chain.custom(this,endStates,this)}toStateJson(topLevelQueryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(topLevelQueryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{Type:state_type_1().StateType.CHOICE,...this.renderQueryLanguage(topLevelQueryLanguage),Comment:this.comment,...this.renderInputOutput(),...this.renderChoices(),...this.renderAssign(topLevelQueryLanguage)}}}exports.Choice=Choice;class DefaultAsNext{choice;constructor(choice){this.choice=choice}next(state){return this.choice.otherwise(state),chain_1().Chain.sequence(this.choice,state)}}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/custom-state.d.ts

@@ -0,0 +1,55 @@
+import type { Construct } from 'constructs';
+import { Chain } from '..';
+import { State } from './state';
+import type { CatchProps, IChainable, INextable, QueryLanguage, RetryProps } from '../types';
+/**
+ * Properties for defining a custom state definition
+ */
+export interface CustomStateProps {
+    /**
+     * Amazon States Language (JSON-based) definition of the state
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html
+     */
+    readonly stateJson: {
+        [key: string]: any;
+    };
+}
+/**
+ * State defined by supplying Amazon States Language (ASL) in the state machine.
+ *
+ */
+export declare class CustomState extends State implements IChainable, INextable {
+    readonly endStates: INextable[];
+    /**
+     * Amazon States Language (JSON-based) definition of the state
+     */
+    private readonly stateJson;
+    constructor(scope: Construct, id: string, props: CustomStateProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): CustomState;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): CustomState;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Returns the Amazon States Language object for this state
+     */
+    toStateJson(queryLanguage?: QueryLanguage): object;
+    private hasMultipleRetrySources;
+    private hasMultipleCatchSources;
+    private addMultipleRetrySourcesWarning;
+    private addMultipleCatchSourcesWarning;
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/custom-state.js

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.CustomState=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var __1=()=>{var tmp=require("..");return __1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},core_1=()=>{var tmp=require("../../../core/");return core_1=()=>tmp,tmp};class CustomState extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.CustomState",version:"2.252.0"};endStates;stateJson;constructor(scope,id,props){super(scope,id,{});try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_CustomStateProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,CustomState),error}this.endStates=[this],this.stateJson=props.stateJson}addRetry(props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_RetryProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addRetry),error}return super._addRetry(props),this}addCatch(handler,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(handler),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_CatchProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addCatch),error}return super._addCatch(handler.startState,props),this}next(next){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(next)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.next),error}return super.makeNext(next.startState),__1().Chain.sequence(this,next)}toStateJson(queryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(queryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}const state={...this.renderQueryLanguage(queryLanguage),...this.renderNextEnd(),...this.stateJson,...this.renderRetryCatch()};return this.hasMultipleRetrySources(state)&&this.addMultipleRetrySourcesWarning(),this.hasMultipleCatchSources(state)&&this.addMultipleCatchSourcesWarning(),Array.isArray(this.stateJson.Retry)&&(state.Retry=Array.isArray(state.Retry)?[...state.Retry,...this.stateJson.Retry]:[...this.stateJson.Retry]),Array.isArray(this.stateJson.Catch)&&(state.Catch=Array.isArray(state.Catch)?[...state.Catch,...this.stateJson.Catch]:[...this.stateJson.Catch]),state}hasMultipleRetrySources(state){return!Array.isArray(state.Retry)||!Array.isArray(this.stateJson.Retry)?!1:state.Retry.length>0&&this.stateJson.Retry.length>0}hasMultipleCatchSources(state){return!Array.isArray(state.Catch)||!Array.isArray(this.stateJson.Catch)?!1:state.Catch.length>0&&this.stateJson.Catch.length>0}addMultipleRetrySourcesWarning(){core_1().Annotations.of(this).addWarningV2("@aws-cdk/aws-stepfunctions:multipleRetrySources",["CustomState constructs can configure state retries using the stateJson property or by using the addRetry() function.","When retries are configured using both of these, the state definition's Retry field is generated ","by first rendering retries from addRetry(), then rendering retries from the stateJson."].join(`
+`))}addMultipleCatchSourcesWarning(){core_1().Annotations.of(this).addWarningV2("@aws-cdk/aws-stepfunctions:multipleCatchSources",["CustomState constructs can configure state catchers using the stateJson property or by using the addCatch() function.","When catchers are configured using both of these, the state definition's Catch field is generated ","by first rendering catchers from addCatch(), then rendering catchers from the stateJson."].join(`
+`))}}exports.CustomState=CustomState;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/distributed-map.d.ts

@@ -0,0 +1,211 @@
+import type { Construct } from 'constructs';
+import type { ItemBatcher } from './distributed-map/item-batcher';
+import type { IItemReader } from './distributed-map/item-reader';
+import type { ResultWriter, ResultWriterV2 } from './distributed-map/result-writer';
+import type { MapBaseJsonataOptions, MapBaseJsonPathOptions, MapBaseOptions, MapBaseProps } from './map-base';
+import { MapBase } from './map-base';
+import { StateGraph } from '../state-graph';
+import { StateMachineType } from '../state-machine';
+import type { CatchProps, IChainable, INextable, ProcessorConfig, RetryProps } from '../types';
+import { QueryLanguage } from '../types';
+import type { StateBaseProps } from './state';
+interface DistributedMapBaseOptions extends MapBaseOptions {
+    /**
+     * MapExecutionType
+     *
+     * The execution type of the distributed map state
+     *
+     * This property overwrites ProcessorConfig.executionType
+     *
+     * @default StateMachineType.STANDARD
+     */
+    readonly mapExecutionType?: StateMachineType;
+    /**
+     * ItemReader
+     *
+     * Configuration for where to read items dataset in S3 to iterate
+     *
+     * @default - No itemReader
+     */
+    readonly itemReader?: IItemReader;
+    /**
+     * ToleratedFailurePercentage
+     *
+     * Percentage of failed items to tolerate in a Map Run, as static number
+     *
+     * @default - No toleratedFailurePercentage
+     */
+    readonly toleratedFailurePercentage?: number;
+    /**
+     * ToleratedFailureCount
+     *
+     * Number of failed items to tolerate in a Map Run, as static number
+     *
+     * @default - No toleratedFailureCount
+     */
+    readonly toleratedFailureCount?: number;
+    /**
+     * Label
+     *
+     * Unique name for the Distributed Map state added to each Map Run
+     *
+     * @default - No label
+     */
+    readonly label?: string;
+    /**
+     * Configuration for S3 location in which to save Map Run results
+     *
+     * @deprecated Use {@link resultWriterV2}
+     * @default - No resultWriter
+     */
+    readonly resultWriter?: ResultWriter;
+    /**
+     * Configuration for S3 location in which to save Map Run results
+     * Enable "@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2" feature in the context to use resultWriterV2
+     * Example: stack.node.setContext("@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2", true);
+     *
+     * @default - No resultWriterV2
+     */
+    readonly resultWriterV2?: ResultWriterV2;
+    /**
+     * Specifies to process a group of items in a single child workflow execution
+     *
+     * @default - No itemBatcher
+     */
+    readonly itemBatcher?: ItemBatcher;
+}
+interface DistributedMapJsonPathOptions extends MapBaseJsonPathOptions {
+    /**
+     * ToleratedFailurePercentagePath
+     *
+     * Percentage of failed items to tolerate in a Map Run, as JsonPath
+     *
+     * @default - No toleratedFailurePercentagePath
+     */
+    readonly toleratedFailurePercentagePath?: string;
+    /**
+     * ToleratedFailureCountPath
+     *
+     * Number of failed items to tolerate in a Map Run, as JsonPath
+     *
+     * @default - No toleratedFailureCountPath
+     */
+    readonly toleratedFailureCountPath?: string;
+}
+/**
+ * Properties for configuring a Distribute Map state that using JSONPath
+ */
+export interface DistributedMapJsonPathProps extends StateBaseProps, DistributedMapBaseOptions, DistributedMapJsonPathOptions {
+}
+/**
+ * Properties for configuring a Distribute Map state that using JSONata
+ */
+export interface DistributedMapJsonataProps extends StateBaseProps, DistributedMapBaseOptions, MapBaseJsonataOptions {
+}
+/**
+ * Properties for configuring a Distribute Map state
+ */
+export interface DistributedMapProps extends MapBaseProps, DistributedMapBaseOptions, DistributedMapJsonPathOptions, MapBaseJsonataOptions {
+}
+/**
+ * Define a Distributed Mode Map state in the state machine
+ *
+ * A `Map` state can be used to run a set of steps for each element of an input array.
+ * A Map state will execute the same steps for multiple entries of an array in the state input.
+ *
+ * While the Parallel state executes multiple branches of steps using the same input, a Map state
+ * will execute the same steps for multiple entries of an array in the state input.
+ *
+ * A `Map` state in `Distributed` mode will execute a child workflow for each iteration of the Map state.
+ * This serves to increase concurrency and allows for larger workloads to be run in a single state machine.
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-distributed.html
+ */
+export declare class DistributedMap extends MapBase implements INextable {
+    /**
+     * Define a Distributed Mode Map state using JSONPath in the state machine
+     *
+     * A `Map` state can be used to run a set of steps for each element of an input array.
+     * A Map state will execute the same steps for multiple entries of an array in the state input.
+     *
+     * While the Parallel state executes multiple branches of steps using the same input, a Map state
+     * will execute the same steps for multiple entries of an array in the state input.
+     *
+     * A `Map` state in `Distributed` mode will execute a child workflow for each iteration of the Map state.
+     * This serves to increase concurrency and allows for larger workloads to be run in a single state machine.
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-distributed.html
+     */
+    static jsonPath(scope: Construct, id: string, props?: DistributedMapJsonPathProps): DistributedMap;
+    /**
+     * Define a Distributed Mode Map state using JSONata in the state machine
+     *
+     * A `Map` state can be used to run a set of steps for each element of an input array.
+     * A Map state will execute the same steps for multiple entries of an array in the state input.
+     *
+     * While the Parallel state executes multiple branches of steps using the same input, a Map state
+     * will execute the same steps for multiple entries of an array in the state input.
+     *
+     * A `Map` state in `Distributed` mode will execute a child workflow for each iteration of the Map state.
+     * This serves to increase concurrency and allows for larger workloads to be run in a single state machine.
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-distributed.html
+     */
+    static jsonata(scope: Construct, id: string, props?: DistributedMapJsonataProps): DistributedMap;
+    /**
+     * Return whether the given object is a DistributedMap.
+     */
+    static isDistributedMap(x: any): x is DistributedMap;
+    private readonly mapExecutionType?;
+    private readonly itemReader?;
+    private readonly toleratedFailurePercentage?;
+    private readonly toleratedFailurePercentagePath?;
+    private readonly toleratedFailureCount?;
+    private readonly toleratedFailureCountPath?;
+    private readonly label?;
+    private readonly resultWriter?;
+    private readonly resultWriterV2?;
+    private readonly itemBatcher?;
+    constructor(scope: Construct, id: string, props?: DistributedMapProps);
+    private getResultWriter;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    protected whenBoundToGraph(graph: StateGraph): void;
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): DistributedMap;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): DistributedMap;
+    /**
+     * Define item processor in a Distributed Map.
+     *
+     * A Distributed Map must have a non-empty item processor
+     */
+    itemProcessor(processor: IChainable, config?: ProcessorConfig): DistributedMap;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(stateMachineQueryLanguage?: QueryLanguage): object;
+    private addWarningIfResultWriterIsEmpty;
+    /**
+     * Render the ItemReader as JSON object
+     */
+    private renderItemReader;
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    private renderResultWriter;
+    /**
+     * Render ItemBatcher in ASL JSON format
+     */
+    private renderItemBatcher;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/distributed-map/item-batcher.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Interface for ItemBatcher configuration properties
+ */
+export interface ItemBatcherProps {
+    /**
+     * MaxItemsPerBatch
+     *
+     * Specifies the maximum number of items that each child workflow execution processes, as static number
+     *
+     * @default - uses value of `maxItemsPerBatchPath` as the max items per batch,
+     *   no limits on the number of items in a batch under the 256KB limit if that property was also not provided
+     */
+    readonly maxItemsPerBatch?: number;
+    /**
+     * MaxItemsPerBatchPath
+     *
+     * Specifies the maximum number of items that each child workflow execution processes, as JsonPath
+     *
+     * @default - uses value of `maxItemsPerBatch` as the max items per batch,
+     *   no limits on the number of items in a batch under the 256KB limit if that property was also not provided
+     */
+    readonly maxItemsPerBatchPath?: string;
+    /**
+     * MaxInputBytesPerBatch
+     *
+     * Specifies the maximum number of bytes that each child workflow execution processes, as static number
+     *
+     * @default - uses value of `maxInputBytesPerBatchPath` as the max size per batch,
+     *   no limits on the batch size under the 256KB limit if that property was also not provided
+     */
+    readonly maxInputBytesPerBatch?: number;
+    /**
+     * MaxInputBytesPerBatchPath
+     *
+     * Specifies the maximum number of bytes that each child workflow execution processes, as JsonPath
+     *
+     * @default - uses value of `maxInputBytesPerBatch` as the max size per batch,
+     *   no limits on the batch size under the 256KB limit if that property was also not provided
+     */
+    readonly maxInputBytesPerBatchPath?: string;
+    /**
+     * BatchInput
+     *
+     * Fixed JSON input to include in each batch passed to each child workflow execution
+     *
+     * @default - No batchInput
+     */
+    readonly batchInput?: object;
+}
+/**
+ * Configuration for processing a group of items in a single child workflow execution
+ */
+export declare class ItemBatcher {
+    private props;
+    constructor(props: ItemBatcherProps);
+    /**
+     * Render ItemBatcher in ASL JSON format
+     */
+    render(): any;
+    /**
+     * Validate this ItemBatcher
+     */
+    validateItemBatcher(): string[];
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/distributed-map/item-batcher.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ItemBatcher=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");class ItemBatcher{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.ItemBatcher",version:"2.252.0"};props;constructor(props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ItemBatcherProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,ItemBatcher),error}this.props=props}render(){return{...this.props.maxItemsPerBatch&&{MaxItemsPerBatch:this.props.maxItemsPerBatch},...this.props.maxItemsPerBatchPath&&{MaxItemsPerBatchPath:this.props.maxItemsPerBatchPath},...this.props.maxInputBytesPerBatch&&{MaxInputBytesPerBatch:this.props.maxInputBytesPerBatch},...this.props.maxInputBytesPerBatchPath&&{MaxInputBytesPerBatchPath:this.props.maxInputBytesPerBatchPath},...this.props.batchInput&&{BatchInput:this.props.batchInput}}}validateItemBatcher(){const errors=[];return this.props.maxItemsPerBatch&&this.props.maxItemsPerBatchPath&&errors.push("Provide either `maxItemsPerBatch` or `maxItemsPerBatchPath`, but not both"),this.props.maxInputBytesPerBatch&&this.props.maxInputBytesPerBatchPath&&errors.push("Provide either `maxInputBytesPerBatch` or `maxInputBytesPerBatchPath`, but not both"),!this.props.maxItemsPerBatch&&!this.props.maxItemsPerBatchPath&&!this.props.maxInputBytesPerBatch&&!this.props.maxInputBytesPerBatchPath&&!this.props.batchInput&&errors.push("Provide at least one value to the ItemBatcher"),errors}}exports.ItemBatcher=ItemBatcher;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/distributed-map/item-reader.d.ts

@@ -0,0 +1,285 @@
+import * as iam from '../../../../aws-iam';
+import type { IBucket } from '../../../../aws-s3';
+import { QueryLanguage } from '../../types';
+/**
+ * Base interface for Item Reader configurations
+ */
+export interface IItemReader {
+    /**
+     * S3 Bucket containing objects to iterate over or a file with a list to iterate over
+     */
+    readonly bucket: IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * The Amazon S3 API action that Step Functions must invoke depending on the specified dataset.
+     */
+    readonly resource: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - Distributed Map state will iterate over all items provided by the ItemReader
+     */
+    readonly maxItems?: number;
+    /**
+     * Render the ItemReader as JSON object
+     */
+    render(queryLanguage?: QueryLanguage): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateItemReader(): string[];
+}
+/**
+ * Base interface for Item Reader configuration properties
+ */
+export interface ItemReaderProps {
+    /**
+     * S3 Bucket containing objects to iterate over or a file with a list to iterate over
+     *
+     * @default - S3 bucket will be determined from @see bucketNamePath
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     *
+     * @default - S3 bucket will be determined from @see bucket
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - Distributed Map state will iterate over all items provided by the ItemReader
+     */
+    readonly maxItems?: number;
+}
+/**
+ * Properties for configuring an Item Reader that iterates over objects in an S3 bucket
+ */
+export interface S3ObjectsItemReaderProps extends ItemReaderProps {
+    /**
+     * S3 prefix used to limit objects to iterate over
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+}
+/**
+ * Item Reader configuration for iterating over objects in an S3 bucket
+ */
+export declare class S3ObjectsItemReader implements IItemReader {
+    private readonly _bucket?;
+    /**
+     * S3 Bucket containing objects to iterate over
+     */
+    get bucket(): IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * ARN for the `listObjectsV2` method of the S3 API
+     * This API method is used to iterate all objects in the S3 bucket/prefix
+     */
+    readonly resource: string;
+    /**
+     * S3 prefix used to limit objects to iterate over
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - Distributed Map state will iterate over all items provided by the ItemReader
+     */
+    readonly maxItems?: number;
+    constructor(props: S3ObjectsItemReaderProps);
+    /**
+     * Renders the ItemReader configuration as JSON object
+     * @returns - JSON object
+     */
+    render(queryLanguage?: QueryLanguage): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateItemReader(): string[];
+}
+/**
+ * Base interface for Item Reader configuration properties the iterate over entries in a S3 file
+ */
+export interface S3FileItemReaderProps extends ItemReaderProps {
+    /**
+     * Key of file stored in S3 bucket containing an array to iterate over
+     */
+    readonly key: string;
+}
+/**
+ * Base Item Reader configuration for iterating over entries in a S3 file
+ */
+declare abstract class S3FileItemReader implements IItemReader {
+    private readonly _bucket?;
+    /**
+     * S3 Bucket containing a file with a list to iterate over
+     */
+    get bucket(): IBucket;
+    /**
+     * S3 bucket name containing objects to iterate over or a file with a list to iterate over, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * S3 key of a file with a list to iterate over
+     */
+    readonly key: string;
+    /**
+     * ARN for the `getObject` method of the S3 API
+     * This API method is used to iterate all objects in the S3 bucket/prefix
+     */
+    readonly resource: string;
+    /**
+     * Limits the number of items passed to the Distributed Map state
+     *
+     * @default - No maxItems
+     */
+    readonly maxItems?: number;
+    protected abstract readonly inputType: string;
+    constructor(props: S3FileItemReaderProps);
+    /**
+     * Renders the ItemReader configuration as JSON object
+     * @returns - JSON object
+     */
+    render(queryLanguage?: QueryLanguage): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ItemReader contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateItemReader(): string[];
+}
+/**
+ * Item Reader configuration for iterating over items in a JSON array stored in a S3 file
+ */
+export declare class S3JsonItemReader extends S3FileItemReader {
+    protected readonly inputType: string;
+}
+/**
+ * Item Reader configuration for iterating over the rows of the JSONL file stored in S3
+ */
+export declare class S3JsonLItemReader extends S3FileItemReader {
+    protected readonly inputType: string;
+}
+/**
+ * CSV header location options
+ */
+export declare enum CsvHeaderLocation {
+    /**
+     * Headers will be read from first row of CSV file
+     */
+    FIRST_ROW = "FIRST_ROW",
+    /**
+     * Headers are provided in CSVHeaders property
+     */
+    GIVEN = "GIVEN"
+}
+/**
+ * Configuration for CSV header options for a CSV Item Reader
+ */
+export declare class CsvHeaders {
+    /**
+     * Configures S3CsvItemReader to read headers from the first row of the CSV file
+     * @returns - CsvHeaders
+     */
+    static useFirstRow(): CsvHeaders;
+    /**
+     * Configures S3CsvItemReader to use the headers provided in the `headers` parameter
+     * @param headers - List of headers
+     * @returns - CsvHeaders
+     */
+    static use(headers: string[]): CsvHeaders;
+    /**
+     * Location of headers in CSV file
+     */
+    readonly headerLocation: CsvHeaderLocation;
+    /**
+     * List of headers if `headerLocation` is `GIVEN`
+     */
+    readonly headers?: string[];
+    private constructor();
+}
+/**
+ * Properties for configuring an Item Reader that iterates over items in a CSV file in S3
+ */
+export interface S3CsvItemReaderProps extends S3FileItemReaderProps {
+    /**
+     * CSV file header configuration
+     *
+     * @default - CsvHeaders with CsvHeadersLocation.FIRST_ROW
+     */
+    readonly csvHeaders?: CsvHeaders;
+    /**
+     * Delimiter used in a CSV file
+     *
+     * @default undefined - Default setting is COMMA.
+     */
+    readonly csvDelimiter?: CsvDelimiter;
+}
+/**
+ * Delimiter used in CSV file
+ */
+export declare enum CsvDelimiter {
+    /**
+     * Comma delimiter
+     */
+    COMMA = "COMMA",
+    /**
+     * Pipe delimiter
+     */
+    PIPE = "PIPE",
+    /**
+     * Semicolon delimiter
+     */
+    SEMICOLON = "SEMICOLON",
+    /**
+     * Space delimiter
+     */
+    SPACE = "SPACE",
+    /**
+     * Tab delimiter
+     */
+    TAB = "TAB"
+}
+/**
+ * Item Reader configuration for iterating over items in a CSV file stored in S3
+ */
+export declare class S3CsvItemReader extends S3FileItemReader {
+    /**
+     * CSV headers configuration
+     */
+    readonly csvHeaders: CsvHeaders;
+    /**
+     * Delimiter used in CSV file
+     */
+    readonly csvDelimiter?: CsvDelimiter;
+    protected readonly inputType: string;
+    constructor(props: S3CsvItemReaderProps);
+    render(queryLanguage?: QueryLanguage): any;
+}
+/**
+ * Item Reader configuration for iterating over items in a S3 inventory manifest file stored in S3
+ */
+export declare class S3ManifestItemReader extends S3FileItemReader {
+    protected readonly inputType: string;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/distributed-map/result-writer.d.ts

@@ -0,0 +1,172 @@
+import * as iam from '../../../../aws-iam';
+import type { IBucket } from '../../../../aws-s3';
+import { QueryLanguage } from '../../types';
+/**
+ * Interface for Result Writer configuration props
+ * @deprecated use {@link ResultWriterV2Props} instead
+ */
+export interface ResultWriterProps {
+    /**
+     * S3 Bucket in which to save Map Run results
+     */
+    readonly bucket: IBucket;
+    /**
+     * S3 prefix in which to save Map Run results
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+}
+/**
+ * Interface for Result Writer configuration props
+ */
+export interface ResultWriterV2Props {
+    /**
+     * S3 Bucket in which to save Map Run results
+     * @default - specify a bucket
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name in which to save Map Run results, as JsonPath
+     *
+     * @default - no bucket path
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * S3 prefix in which to save Map Run results
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+    /**
+     * Configuration to format the output of the Child Workflow executions
+     *
+     * @default - Specify both Transformation and OutputType
+     */
+    readonly writerConfig?: WriterConfig;
+}
+/**
+ * The transformation to be applied to the Output of the Child Workflow executions
+ */
+export declare enum Transformation {
+    /**
+     * Returns the output of the child workflow executions unchanged, in addition to the workflow metadata.
+     * Default when exporting the child workflow execution results to Amazon S3 and WriterConfig is not specified.
+     */
+    NONE = "NONE",
+    /**
+     * Returns the output of the child workflow executions. Default when ResultWriter is not specified.
+     */
+    COMPACT = "COMPACT",
+    /**
+     * Returns the output of the child workflow executions.
+     * If a child workflow execution returns an array,this option flattens the array,
+     * prior to returning the result to a state output or writing the result to an Amazon S3 object.
+     */
+    FLATTEN = "FLATTEN"
+}
+/**
+ * The format of the Output of the child workflow executions
+ */
+export declare enum OutputType {
+    /**
+     * Formats the results as a JSON array
+     */
+    JSON = "JSON",
+    /**
+     * Formats the results as JSON Lines
+     */
+    JSONL = "JSONL"
+}
+/**
+ * Interface for Writer Config props
+ */
+export interface WriterConfigProps {
+    /**
+     * The transformation to be applied to the Output of the Child Workflow executions
+     */
+    readonly transformation: Transformation;
+    /**
+     * The format of the Output of the child workflow executions
+     */
+    readonly outputType: OutputType;
+}
+/**
+ * Configuration to format the output
+ */
+export declare class WriterConfig {
+    /**
+     * The transformation to be applied to the Output of the Child Workflow executions
+     */
+    readonly transformation: Transformation;
+    /**
+     * The format of the Output of the child workflow executions
+     */
+    readonly outputType: OutputType;
+    constructor(props: WriterConfigProps);
+}
+/**
+ * Configuration for writing Distributed Map state results to S3
+ * @deprecated use {@link ResultWriterV2} instead
+ */
+export declare class ResultWriter {
+    /**
+     * S3 Bucket in which to save Map Run results
+     */
+    readonly bucket: IBucket;
+    /**
+     * S3 prefix in which to save Map Run results
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+    constructor(props: ResultWriterProps);
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    render(queryLanguage?: QueryLanguage): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+}
+/**
+ * Configuration for writing Distributed Map state results to S3
+ * The ResultWriter field cannot be empty. You must specify one of these sets of sub-fields.
+ *   writerConfig - to preview the formatted output, without saving the results to Amazon S3.
+ *   bucket and prefix - to save the results to Amazon S3 without additional formatting.
+ *   All three fields: writerConfig, bucket and prefix - to format the output and save it to Amazon S3.
+ */
+export declare class ResultWriterV2 {
+    /**
+     * S3 Bucket in which to save Map Run results
+     */
+    readonly bucket?: IBucket;
+    /**
+     * S3 bucket name in which to save Map Run results, as JsonPath
+     */
+    readonly bucketNamePath?: string;
+    /**
+     * S3 prefix in which to save Map Run results
+     *
+     * @default - No prefix
+     */
+    readonly prefix?: string;
+    /**
+     * Configuration to format the output of the Child Workflow executions
+     */
+    readonly writerConfig?: WriterConfig;
+    constructor(props: ResultWriterV2Props);
+    /**
+     * Render ResultWriter in ASL JSON format
+     */
+    render(queryLanguage?: QueryLanguage): any;
+    /**
+     * Compile policy statements to provide relevent permissions to the state machine
+     */
+    providePolicyStatements(): iam.PolicyStatement[];
+    /**
+     * Validate that ResultWriter contains exactly either @see bucket or @see bucketNamePath
+     */
+    validateResultWriter(): string[];
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/fail.d.ts

@@ -0,0 +1,91 @@
+import type { Construct } from 'constructs';
+import type { StateBaseProps } from './state';
+import { State } from './state';
+import type { INextable } from '../types';
+import { QueryLanguage } from '../types';
+interface FailBaseOptions {
+    /**
+     * Error code used to represent this failure
+     *
+     * @default - No error code
+     */
+    readonly error?: string;
+    /**
+     * A description for the cause of the failure
+     *
+     * @default - No description
+     */
+    readonly cause?: string;
+}
+interface FailJsonPathOptions {
+    /**
+     * JsonPath expression to select part of the state to be the error to this state.
+     *
+     * You can also use an intrinsic function that returns a string to specify this property.
+     * The allowed functions include States.Format, States.JsonToString, States.ArrayGetItem, States.Base64Encode, States.Base64Decode, States.Hash, and States.UUID.
+     *
+     * @default - No error path
+     */
+    readonly errorPath?: string;
+    /**
+     * JsonPath expression to select part of the state to be the cause to this state.
+     *
+     * You can also use an intrinsic function that returns a string to specify this property.
+     * The allowed functions include States.Format, States.JsonToString, States.ArrayGetItem, States.Base64Encode, States.Base64Decode, States.Hash, and States.UUID.
+     *
+     * @default - No cause path
+     */
+    readonly causePath?: string;
+}
+/**
+ * Properties for defining a Fail state that using JSONPath
+ */
+export interface FailJsonPathProps extends StateBaseProps, FailBaseOptions, FailJsonPathOptions {
+}
+/**
+ * Properties for defining a Fail state that using JSONata
+ */
+export interface FailJsonataProps extends StateBaseProps, FailBaseOptions {
+}
+/**
+ * Properties for defining a Fail state
+ */
+export interface FailProps extends StateBaseProps, FailBaseOptions, FailJsonPathOptions {
+}
+/**
+ * Define a Fail state in the state machine
+ *
+ * Reaching a Fail state terminates the state execution in failure.
+ */
+export declare class Fail extends State {
+    /**
+     * Define a Fail state using JSONPath in the state machine
+     *
+     * Reaching a Fail state terminates the state execution in failure.
+     */
+    static jsonPath(scope: Construct, id: string, props?: FailJsonPathProps): Fail;
+    /**
+     * Define a Fail state using JSONata in the state machine
+     *
+     * Reaching a Fail state terminates the state execution in failure.
+     */
+    static jsonata(scope: Construct, id: string, props?: FailJsonataProps): Fail;
+    private static allowedIntrinsics;
+    readonly endStates: INextable[];
+    private readonly error?;
+    private readonly errorPath?;
+    private readonly cause?;
+    private readonly causePath?;
+    constructor(scope: Construct, id: string, props?: FailProps);
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(queryLanguage?: QueryLanguage): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    private isIntrinsicString;
+    private isAllowedIntrinsic;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/fail.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Fail=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},core_1=()=>{var tmp=require("../../../core");return core_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class Fail extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Fail",version:"2.252.0"};static jsonPath(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_FailJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Fail(scope,id,props)}static jsonata(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_FailJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Fail(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}static allowedIntrinsics=["States.Format","States.JsonToString","States.ArrayGetItem","States.Base64Encode","States.Base64Decode","States.Hash","States.UUID"];endStates=[];error;errorPath;cause;causePath;constructor(scope,id,props={}){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_FailProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Fail),error}this.error=props.error,this.errorPath=props.errorPath,this.cause=props.cause,this.causePath=props.causePath}toStateJson(queryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(queryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{Type:state_type_1().StateType.FAIL,...this.renderQueryLanguage(queryLanguage),Comment:this.comment,Error:this.error,ErrorPath:this.isIntrinsicString(this.errorPath)?this.errorPath:(0,state_1().renderJsonPath)(this.errorPath),Cause:this.cause,CausePath:this.isIntrinsicString(this.causePath)?this.causePath:(0,state_1().renderJsonPath)(this.causePath)}}validateState(){const errors=super.validateState();return this.errorPath&&this.isIntrinsicString(this.errorPath)&&!this.isAllowedIntrinsic(this.errorPath)&&errors.push(`You must specify a valid intrinsic function in errorPath. Must be one of ${Fail.allowedIntrinsics.join(", ")}`),this.causePath&&this.isIntrinsicString(this.causePath)&&!this.isAllowedIntrinsic(this.causePath)&&errors.push(`You must specify a valid intrinsic function in causePath. Must be one of ${Fail.allowedIntrinsics.join(", ")}`),this.error&&this.errorPath&&errors.push("Fail state cannot have both error and errorPath"),this.cause&&this.causePath&&errors.push("Fail state cannot have both cause and causePath"),errors}isIntrinsicString(jsonPath){return!core_1().Token.isUnresolved(jsonPath)&&!jsonPath?.startsWith("$")}isAllowedIntrinsic(intrinsic){return Fail.allowedIntrinsics.some(allowed=>intrinsic.startsWith(allowed))}}exports.Fail=Fail;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/map-base.d.ts

@@ -0,0 +1,186 @@
+import type { Construct } from 'constructs';
+import type { AssignableStateOptions, JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import { Chain } from '../chain';
+import type { IChainable, INextable, QueryLanguage } from '../types';
+/**
+ * Base properties for defining a Map state that using JSONPath
+ */
+export interface MapBaseJsonPathOptions extends JsonPathCommonOptions {
+    /**
+     * JSONPath expression to select the array to iterate over
+     *
+     * @default $
+     */
+    readonly itemsPath?: string;
+    /**
+     * MaxConcurrencyPath
+     *
+     * A JsonPath that specifies the maximum concurrency dynamically from the state input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields
+     *
+     * @default - full concurrency
+     */
+    readonly maxConcurrencyPath?: string;
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * The JSON that will replace the state's raw result and become the effective
+     * result before ResultPath is applied.
+     *
+     * You can use ResultSelector to create a payload with values that are static
+     * or selected from the state's raw result.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+     *
+     * @default - None
+     */
+    readonly resultSelector?: {
+        [key: string]: any;
+    };
+}
+/**
+ * The array that the Map state will iterate over.
+ */
+export declare abstract class ProvideItems {
+    /**
+     * Use a JSON array as Map state items.
+     *
+     * Example value: `[1, "{% $two %}", 3]`
+     */
+    static jsonArray(array: any[]): ProvideItems;
+    /**
+     * Use a JSONata expression as Map state items.
+     *
+     * Example value: `{% $states.input.items %}`
+     */
+    static jsonata(jsonataExpression: string): ProvideItems;
+    /**
+     * The array that the Map state will iterate over.
+     */
+    abstract readonly items: any;
+}
+/**
+ * Base properties for defining a Map state that using JSONata
+ */
+export interface MapBaseJsonataOptions extends JsonataCommonOptions {
+    /**
+     * The array that the Map state will iterate over.
+     * @default - The state input as is.
+     */
+    readonly items?: ProvideItems;
+}
+/**
+ * Base properties for defining a Map state
+ */
+export interface MapBaseOptions extends AssignableStateOptions {
+    /**
+     * MaxConcurrency
+     *
+     * An upper bound on the number of iterations you want running at once.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields
+     *
+     * @default - full concurrency
+     */
+    readonly maxConcurrency?: number;
+    /**
+     * JSONata expression for MaxConcurrency
+     *
+     * A JSONata expression that evaluates to an integer, specifying the maximum
+     * concurrency dynamically. Mutually exclusive with `maxConcurrency` and
+     * `maxConcurrencyPath`.
+     *
+     * Example value: `{% $states.input.maxConcurrency %}`
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-asl-use-map-state-inline.html#map-state-inline-additional-fields
+     *
+     * @default - full concurrency
+     */
+    readonly jsonataMaxConcurrency?: string;
+    /**
+     * The JSON that you want to override your default iteration input (mutually exclusive  with `parameters` and `jsonataItemSelector`).
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html
+     *
+     * @default $
+     */
+    readonly itemSelector?: {
+        [key: string]: any;
+    };
+    /**
+     * Jsonata expression that evaluates to a JSON array to override your default iteration input (mutually exclusive with `parameters` and `itemSelector`).
+     *
+     * Example value: `{% {\"foo\": \"foo\", \"input\": $states.input} %}`
+     *
+     * @default $
+     */
+    readonly jsonataItemSelector?: string;
+}
+/**
+ * Properties for defining a Map state
+ */
+export interface MapBaseProps extends StateBaseProps, MapBaseOptions, MapBaseJsonPathOptions, MapBaseJsonataOptions {
+}
+/**
+ * Returns true if the value passed is a positive integer
+ * @param value the value to validate
+ */
+export declare const isPositiveInteger: (value: number) => boolean;
+/**
+ * Define a Map state in the state machine
+ *
+ * A `Map` state can be used to run a set of steps for each element of an input array.
+ * A Map state will execute the same steps for multiple entries of an array in the state input.
+ *
+ * While the Parallel state executes multiple branches of steps using the same input, a Map state
+ * will execute the same steps for multiple entries of an array in the state input.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+ */
+export declare abstract class MapBase extends State implements INextable {
+    readonly endStates: INextable[];
+    private readonly maxConcurrency?;
+    private readonly maxConcurrencyPath?;
+    private readonly jsonataMaxConcurrency?;
+    protected readonly items?: ProvideItems;
+    protected readonly itemsPath?: string;
+    protected readonly itemSelector?: {
+        [key: string]: any;
+    };
+    protected readonly jsonataItemSelector?: string;
+    constructor(scope: Construct, id: string, props?: MapBaseProps);
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(topLevelQueryLanguage?: QueryLanguage): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    private renderItemsPath;
+    /**
+     * Render ItemSelector in ASL JSON format
+     */
+    private renderItemSelector;
+    /**
+     * Render MaxConcurrency in ASL JSON format
+     */
+    private renderMaxConcurrency;
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/map.d.ts

@@ -0,0 +1,116 @@
+import type { Construct } from 'constructs';
+import type { MapBaseJsonataOptions, MapBaseJsonPathOptions, MapBaseOptions, MapBaseProps } from './map-base';
+import { MapBase } from './map-base';
+import type { CatchProps, IChainable, INextable, ProcessorConfig, RetryProps } from '../types';
+import { QueryLanguage } from '../types';
+import type { StateBaseProps } from './state';
+interface MapOptions extends MapBaseOptions {
+    /**
+     * The JSON that you want to override your default iteration input (mutually exclusive  with `itemSelector`).
+     *
+     * @deprecated Step Functions has deprecated the `parameters` field in favor of
+     * the new `itemSelector` field
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-itemselector.html
+     *
+     * @default $
+     */
+    readonly parameters?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Properties for defining a Map state that using JSONPath
+ */
+export interface MapJsonPathProps extends StateBaseProps, MapOptions, MapBaseJsonPathOptions {
+}
+/**
+ * Properties for defining a Map state that using JSONata
+ */
+export interface MapJsonataProps extends StateBaseProps, MapOptions, MapBaseJsonataOptions {
+}
+/**
+ * Properties for defining a Map state
+ */
+export interface MapProps extends MapBaseProps, MapOptions {
+}
+/**
+ * Define a Map state in the state machine
+ *
+ * A `Map` state can be used to run a set of steps for each element of an input array.
+ * A Map state will execute the same steps for multiple entries of an array in the state input.
+ *
+ * While the Parallel state executes multiple branches of steps using the same input, a Map state
+ * will execute the same steps for multiple entries of an array in the state input.
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+ */
+export declare class Map extends MapBase implements INextable {
+    /**
+     * Define a Map state using JSONPath in the state machine
+     *
+     * A `Map` state can be used to run a set of steps for each element of an input array.
+     * A Map state will execute the same steps for multiple entries of an array in the state input.
+     *
+     * While the Parallel state executes multiple branches of steps using the same input, a Map state
+     * will execute the same steps for multiple entries of an array in the state input.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+     */
+    static jsonPath(scope: Construct, id: string, props?: MapJsonPathProps): Map;
+    /**
+     * Define a Map state using JSONata in the state machine
+     *
+     * A `Map` state can be used to run a set of steps for each element of an input array.
+     * A Map state will execute the same steps for multiple entries of an array in the state input.
+     *
+     * While the Parallel state executes multiple branches of steps using the same input, a Map state
+     * will execute the same steps for multiple entries of an array in the state input.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-map-state.html
+     */
+    static jsonata(scope: Construct, id: string, props?: MapJsonataProps): Map;
+    constructor(scope: Construct, id: string, props?: MapProps);
+    /**
+     * Define iterator state machine in Map.
+     *
+     * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `itemProcessor`).
+     *
+     * @deprecated - use `itemProcessor` instead.
+     */
+    iterator(iterator: IChainable): Map;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(queryLanguage?: QueryLanguage): object;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+    /**
+     * Render Parameters in ASL JSON format
+     */
+    private renderParameters;
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): Map;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): Map;
+    /**
+     * Define item processor in Map.
+     *
+     * A Map must either have a non-empty iterator or a non-empty item processor (mutually exclusive  with `iterator`).
+     */
+    itemProcessor(processor: IChainable, config?: ProcessorConfig): Map;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/map.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Map=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var map_base_1=()=>{var tmp=require("./map-base");return map_base_1=()=>tmp,tmp},fields_1=()=>{var tmp=require("../fields");return fields_1=()=>tmp,tmp},state_graph_1=()=>{var tmp=require("../state-graph");return state_graph_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class Map extends map_base_1().MapBase{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Map",version:"2.252.0"};static jsonPath(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_MapJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Map(scope,id,props)}static jsonata(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_MapJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Map(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}constructor(scope,id,props={}){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_MapProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Map),error}this.processorMode=types_1().ProcessorMode.INLINE}iterator(iterator){try{jsiiDeprecationWarnings().print("aws-cdk-lib.aws_stepfunctions.Map#iterator","- use `itemProcessor`\xA0instead."),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(iterator)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.iterator),error}const name=`Map ${this.stateId} Iterator`;return super.addIterator(new(state_graph_1()).StateGraph(iterator.startState,name)),this}toStateJson(queryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(queryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{...super.toStateJson(queryLanguage),...this.renderParameters(),...this.renderIterator()}}validateState(){const errors=super.validateState();return!this.iteration&&!this.processor&&errors.push("Map state must either have a non-empty iterator or a non-empty item processor"),this.iteration&&this.processor&&errors.push("Map state cannot have both an iterator and an item processor"),this.parameters&&(this.itemSelector||this.jsonataItemSelector)&&errors.push("Map state cannot have both parameters and an item selector"),errors}renderParameters(){if(this.parameters)return fields_1().FieldUtils.renderObject({Parameters:this.parameters})}addRetry(props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_RetryProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addRetry),error}return super._addRetry(props),this}addCatch(handler,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(handler),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_CatchProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addCatch),error}return super._addCatch(handler.startState,props),this}itemProcessor(processor,config={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(processor),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ProcessorConfig(config)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.itemProcessor),error}const name=`Map ${this.stateId} Item Processor`,stateGraph=new(state_graph_1()).StateGraph(processor.startState,name);return super.addItemProcessor(stateGraph,config),this}}exports.Map=Map;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/parallel.d.ts

@@ -0,0 +1,144 @@
+import type { Construct } from 'constructs';
+import type { AssignableStateOptions, JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import { Chain } from '../chain';
+import { StateGraph } from '../state-graph';
+import type { CatchProps, IChainable, INextable, RetryProps } from '../types';
+import { QueryLanguage } from '../types';
+interface ParallelJsonPathOptions extends JsonPathCommonOptions {
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * The JSON that will replace the state's raw result and become the effective
+     * result before ResultPath is applied.
+     *
+     * You can use ResultSelector to create a payload with values that are static
+     * or selected from the state's raw result.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+     *
+     * @default - None
+     */
+    readonly resultSelector?: {
+        [key: string]: any;
+    };
+    /**
+     * Parameters pass a collection of key-value pairs, either static values or JSONPath expressions that select from the input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters
+     *
+     * @default No parameters
+     */
+    readonly parameters?: {
+        [name: string]: any;
+    };
+}
+interface ParallelJsonataOptions extends JsonataCommonOptions {
+    /**
+     * Parameters pass a collection of key-value pairs, either static values or JSONata expressions that select from the input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/transforming-data.html
+     *
+     * @default No arguments
+     */
+    readonly arguments?: {
+        [name: string]: any;
+    };
+}
+/**
+ * Properties for defining a Parallel state that using JSONPath
+ */
+export interface ParallelJsonPathProps extends StateBaseProps, AssignableStateOptions, ParallelJsonPathOptions {
+}
+/**
+ * Properties for defining a Parallel state that using JSONata
+ */
+export interface ParallelJsonataProps extends StateBaseProps, AssignableStateOptions, ParallelJsonataOptions {
+}
+/**
+ * Properties for defining a Parallel state
+ */
+export interface ParallelProps extends StateBaseProps, AssignableStateOptions, ParallelJsonPathOptions, ParallelJsonataOptions {
+}
+/**
+ * Define a Parallel state in the state machine
+ *
+ * A Parallel state can be used to run one or more state machines at the same
+ * time.
+ *
+ * The Result of a Parallel state is an array of the results of its substatemachines.
+ */
+export declare class Parallel extends State implements INextable {
+    /**
+     * Define a Parallel state using JSONPath in the state machine
+     *
+     * A Parallel state can be used to run one or more state machines at the same
+     * time.
+     *
+     * The Result of a Parallel state is an array of the results of its substatemachines.
+     */
+    static jsonPath(scope: Construct, id: string, props?: ParallelJsonPathProps): Parallel;
+    /**
+     * Define a Parallel state using JSONata in the state machine
+     *
+     * A Parallel state can be used to run one or more state machines at the same
+     * time.
+     *
+     * The Result of a Parallel state is an array of the results of its substatemachines.
+     */
+    static jsonata(scope: Construct, id: string, props?: ParallelJsonataProps): Parallel;
+    readonly endStates: INextable[];
+    private readonly _branches;
+    constructor(scope: Construct, id: string, props?: ParallelProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): Parallel;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): Parallel;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Define one or more branches to run in parallel
+     */
+    branch(...branches: IChainable[]): Parallel;
+    /**
+     * Overwrites State.bindToGraph. Adds branches to
+     * the Parallel state here so that any necessary
+     * prefixes are appended first.
+     */
+    bindToGraph(graph: StateGraph): void;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(topLevelQueryLanguage?: QueryLanguage): object;
+    /**
+     * Render Parameters in ASL JSON format
+     */
+    private renderParameters;
+    /**
+     * Validate this state
+     */
+    protected validateState(): string[];
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/parallel.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Parallel=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},chain_1=()=>{var tmp=require("../chain");return chain_1=()=>tmp,tmp},fields_1=()=>{var tmp=require("../fields");return fields_1=()=>tmp,tmp},state_graph_1=()=>{var tmp=require("../state-graph");return state_graph_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class Parallel extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Parallel",version:"2.252.0"};static jsonPath(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ParallelJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Parallel(scope,id,props)}static jsonata(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ParallelJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Parallel(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}endStates;_branches=[];constructor(scope,id,props={}){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_ParallelProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Parallel),error}this.endStates=[this]}addRetry(props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_RetryProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addRetry),error}return super._addRetry(props),this}addCatch(handler,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(handler),jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_CatchProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.addCatch),error}return super._addCatch(handler.startState,props),this}next(next){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(next)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.next),error}return super.makeNext(next.startState),chain_1().Chain.sequence(this,next)}branch(...branches){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(branches)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.branch),error}return this._branches.push(...branches),this}bindToGraph(graph){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_StateGraph(graph)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.bindToGraph),error}for(const branch of this._branches){const name=`Parallel '${this.stateId}' branch ${this.branches.length+1}`;super.addBranch(new(state_graph_1()).StateGraph(branch.startState,name))}return this._branches.splice(0,this._branches.length),super.bindToGraph(graph)}toStateJson(topLevelQueryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(topLevelQueryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{Type:state_type_1().StateType.PARALLEL,...this.renderQueryLanguage(topLevelQueryLanguage),Comment:this.comment,ResultPath:(0,state_1().renderJsonPath)(this.resultPath),...this.renderNextEnd(),...this.renderInputOutput(),...this.renderRetryCatch(),...this.renderBranches(),...this.renderResultSelector(),...this.renderParameters(),...this.renderAssign(topLevelQueryLanguage)}}renderParameters(){if(this.parameters)return fields_1().FieldUtils.renderObject({Parameters:this.parameters})}validateState(){return this.branches.length===0?["Parallel must have at least one branch"]:[]}}exports.Parallel=Parallel;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/pass.d.ts

@@ -0,0 +1,119 @@
+import type { Construct } from 'constructs';
+import type { AssignableStateOptions, JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import { Chain } from '../chain';
+import type { IChainable, INextable } from '../types';
+import { QueryLanguage } from '../types';
+/**
+ * The result of a Pass operation
+ */
+export declare class Result {
+    readonly value: any;
+    /**
+     * The result of the operation is a string
+     */
+    static fromString(value: string): Result;
+    /**
+     * The result of the operation is a number
+     */
+    static fromNumber(value: number): Result;
+    /**
+     * The result of the operation is a boolean
+     */
+    static fromBoolean(value: boolean): Result;
+    /**
+     * The result of the operation is an object
+     */
+    static fromObject(value: {
+        [key: string]: any;
+    }): Result;
+    /**
+     * The result of the operation is an array
+     */
+    static fromArray(value: any[]): Result;
+    /**
+     *
+     * @param value result of the Pass operation
+     */
+    protected constructor(value: any);
+}
+interface PassJsonPathOptions extends JsonPathCommonOptions {
+    /**
+     * If given, treat as the result of this operation
+     *
+     * Can be used to inject or replace the current execution state.
+     *
+     * @default No injected result
+     */
+    readonly result?: Result;
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * Parameters pass a collection of key-value pairs, either static values or JSONPath expressions that select from the input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters
+     *
+     * @default No parameters
+     */
+    readonly parameters?: {
+        [name: string]: any;
+    };
+}
+/**
+ * Properties for defining a Pass state that using JSONPath
+ */
+export interface PassJsonPathProps extends StateBaseProps, AssignableStateOptions, PassJsonPathOptions {
+}
+/**
+ * Properties for defining a Pass state that using JSONata
+ */
+export interface PassJsonataProps extends StateBaseProps, AssignableStateOptions, JsonataCommonOptions {
+}
+/**
+ * Properties for defining a Pass state
+ */
+export interface PassProps extends StateBaseProps, AssignableStateOptions, PassJsonPathOptions, JsonataCommonOptions {
+}
+/**
+ * Define a Pass in the state machine
+ *
+ * A Pass state can be used to transform the current execution's state.
+ */
+export declare class Pass extends State implements INextable {
+    /**
+     * Define a Pass using JSONPath in the state machine
+     *
+     * A Pass state can be used to transform the current execution's state.
+     */
+    static jsonPath(scope: Construct, id: string, props?: PassJsonPathProps): Pass;
+    /**
+     * Define a Pass using JSONata in the state machine
+     *
+     * A Pass state can be used to transform the current execution's state.
+     */
+    static jsonata(scope: Construct, id: string, props?: PassJsonataProps): Pass;
+    readonly endStates: INextable[];
+    private readonly result?;
+    constructor(scope: Construct, id: string, props?: PassProps);
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(topLevelQueryLanguage?: QueryLanguage): object;
+    /**
+     * Render Parameters in ASL JSON format
+     */
+    private renderParameters;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/pass.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Pass=exports.Result=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},chain_1=()=>{var tmp=require("../chain");return chain_1=()=>tmp,tmp},fields_1=()=>{var tmp=require("../fields");return fields_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class Result{value;static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Result",version:"2.252.0"};static fromString(value){return new Result(value)}static fromNumber(value){return new Result(value)}static fromBoolean(value){return new Result(value)}static fromObject(value){return new Result(value)}static fromArray(value){return new Result(value)}constructor(value){this.value=value}}exports.Result=Result;class Pass extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Pass",version:"2.252.0"};static jsonPath(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_PassJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Pass(scope,id,props)}static jsonata(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_PassJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Pass(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}endStates;result;constructor(scope,id,props={}){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_PassProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Pass),error}this.result=props.result,this.endStates=[this]}next(next){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(next)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.next),error}return super.makeNext(next.startState),chain_1().Chain.sequence(this,next)}toStateJson(topLevelQueryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(topLevelQueryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{Type:state_type_1().StateType.PASS,...this.renderQueryLanguage(topLevelQueryLanguage),Comment:this.comment,Result:this.result?.value,ResultPath:(0,state_1().renderJsonPath)(this.resultPath),...this.renderInputOutput(),...this.renderParameters(),...this.renderNextEnd(),...this.renderAssign(topLevelQueryLanguage)}}renderParameters(){return fields_1().FieldUtils.renderObject({Parameters:this.parameters})}}exports.Pass=Pass;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/private/state-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * State types
+ */
+export declare enum StateType {
+    PASS = "Pass",
+    TASK = "Task",
+    CHOICE = "Choice",
+    WAIT = "Wait",
+    SUCCEED = "Succeed",
+    FAIL = "Fail",
+    PARALLEL = "Parallel",
+    MAP = "Map"
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/private/state-type.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.StateType=void 0;var StateType;(function(StateType2){StateType2.PASS="Pass",StateType2.TASK="Task",StateType2.CHOICE="Choice",StateType2.WAIT="Wait",StateType2.SUCCEED="Succeed",StateType2.FAIL="Fail",StateType2.PARALLEL="Parallel",StateType2.MAP="Map"})(StateType||(exports.StateType=StateType={}));

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/state.d.ts

@@ -0,0 +1,388 @@
+import type { IConstruct } from 'constructs';
+import { Construct } from 'constructs';
+import type { Condition } from '../condition';
+import type { StateGraph } from '../state-graph';
+import type { CatchProps, IChainable, INextable, ProcessorConfig, RetryProps } from '../types';
+import { ProcessorMode, QueryLanguage } from '../types';
+/**
+ * Properties shared by all states
+ */
+export interface StateBaseProps {
+    /**
+     * The name of the query language used by the state.
+     * If the state does not contain a `queryLanguage` field,
+     * then it will use the query language specified in the top-level `queryLanguage` field.
+     *
+     * @default - JSONPath
+     */
+    readonly queryLanguage?: QueryLanguage;
+    /**
+     * Optional name for this state
+     *
+     * @default - The construct ID will be used as state name
+     */
+    readonly stateName?: string;
+    /**
+     * A comment describing this state
+     *
+     * @default No comment
+     */
+    readonly comment?: string;
+}
+/**
+ * Option properties for JSONPath state.
+ */
+export interface JsonPathCommonOptions {
+    /**
+     * JSONPath expression to select part of the state to be the input to this state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * input to be the empty object {}.
+     *
+     * @default $
+     */
+    readonly inputPath?: string;
+    /**
+     * JSONPath expression to select part of the state to be the output to this state.
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the effective
+     * output to be the empty object {}.
+     *
+     * @default $
+     */
+    readonly outputPath?: string;
+}
+interface JsonPathStateOptions extends JsonPathCommonOptions {
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * The JSON that will replace the state's raw result and become the effective
+     * result before ResultPath is applied.
+     *
+     * You can use ResultSelector to create a payload with values that are static
+     * or selected from the state's raw result.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+     *
+     * @default - None
+     */
+    readonly resultSelector?: {
+        [key: string]: any;
+    };
+    /**
+     * Parameters pass a collection of key-value pairs, either static values or JSONPath expressions that select from the input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-parameters
+     *
+     * @default No parameters
+     */
+    readonly parameters?: {
+        [name: string]: any;
+    };
+}
+/**
+ * Option properties for JSONata state.
+ */
+export interface JsonataCommonOptions {
+    /**
+     * Used to specify and transform output from the state.
+     * When specified, the value overrides the state output default.
+     * The output field accepts any JSON value (object, array, string, number, boolean, null).
+     * Any string value, including those inside objects or arrays,
+     * will be evaluated as JSONata if surrounded by {% %} characters.
+     * Output also accepts a JSONata expression directly.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-input-output-filtering.html
+     *
+     * @default - $states.result or $states.errorOutput
+     */
+    readonly outputs?: any;
+}
+/**
+ * Option properties for JSONata task state.
+ */
+export interface JsonataStateOptions extends JsonataCommonOptions {
+    /**
+     * Parameters pass a collection of key-value pairs, either static values or JSONata expressions that select from the input.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/transforming-data.html
+     *
+     * @default - No arguments
+     */
+    readonly arguments?: any;
+}
+/**
+ * Option properties for state that can assign variables.
+ */
+export interface AssignableStateOptions {
+    /**
+     * Workflow variables to store in this step.
+     * Using workflow variables, you can store data in a step and retrieve that data in future steps.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/workflow-variables.html
+     *
+     * @default - Not assign variables
+     */
+    readonly assign?: {
+        [name: string]: any;
+    };
+}
+/**
+ * Properties shared by all states that use JSONPath
+ */
+export interface JsonPathStateProps extends StateBaseProps, JsonPathStateOptions, AssignableStateOptions {
+}
+/**
+ * Properties shared by all states that use JSONata
+ */
+export interface JsonataStateProps extends StateBaseProps, JsonataStateOptions, AssignableStateOptions {
+}
+/**
+ * Properties shared by all states
+ */
+export interface StateProps extends StateBaseProps, JsonPathStateOptions, JsonataStateOptions, AssignableStateOptions {
+}
+/**
+ * Base class for all other state classes
+ */
+export declare abstract class State extends Construct implements IChainable {
+    /**
+     * Add a prefix to the stateId of all States found in a construct tree
+     */
+    static prefixStates(root: IConstruct, prefix: string): void;
+    /**
+     * Find the set of states reachable through transitions from the given start state.
+     * This does not retrieve states from within sub-graphs, such as states within a Parallel state's branch.
+     */
+    static findReachableStates(start: State, options?: FindStateOptions): State[];
+    /**
+     * Find the set of end states states reachable through transitions from the given start state
+     */
+    static findReachableEndStates(start: State, options?: FindStateOptions): State[];
+    /**
+     * Return only the states that allow chaining from an array of states
+     */
+    static filterNextables(states: State[]): INextable[];
+    /**
+     * First state of this Chainable
+     */
+    readonly startState: State;
+    /**
+     * Continuable states of this Chainable
+     */
+    abstract readonly endStates: INextable[];
+    protected readonly stateName?: string;
+    protected readonly comment?: string;
+    protected readonly inputPath?: string;
+    protected readonly parameters?: object;
+    protected readonly outputPath?: string;
+    protected readonly resultPath?: string;
+    protected readonly resultSelector?: object;
+    protected readonly branches: StateGraph[];
+    protected readonly queryLanguage?: QueryLanguage;
+    protected readonly outputs?: object;
+    protected readonly arguments?: object;
+    protected readonly assign?: object;
+    protected iteration?: StateGraph;
+    protected processorMode?: ProcessorMode;
+    protected processor?: StateGraph;
+    protected processorConfig?: ProcessorConfig;
+    protected defaultChoice?: State;
+    /**
+     * @internal
+     */
+    protected _next?: State;
+    private readonly retries;
+    private readonly catches;
+    private readonly choices;
+    private readonly prefixes;
+    /**
+     * The graph that this state is part of.
+     *
+     * Used for guaranteeing consistency between graphs and graph components.
+     */
+    private containingGraph?;
+    /**
+     * States with references to this state.
+     *
+     * Used for finding complete connected graph that a state is part of.
+     */
+    private readonly incomingStates;
+    constructor(scope: Construct, id: string, props: StateProps);
+    /**
+     * Allows the state to validate itself.
+     */
+    protected validateState(): string[];
+    get id(): string;
+    /**
+     * Tokenized string that evaluates to the state's ID
+     */
+    get stateId(): string;
+    /**
+     * Add a prefix to the stateId of this state
+     */
+    addPrefix(x: string): void;
+    /**
+     * Register this state as part of the given graph
+     *
+     * Don't call this. It will be called automatically when you work
+     * with states normally.
+     */
+    bindToGraph(graph: StateGraph): void;
+    /**
+     * Render the state as JSON
+     */
+    abstract toStateJson(stateMachineQueryLanguage?: QueryLanguage): object;
+    /**
+     * Add a retrier to the retry list of this state
+     * @internal
+     */
+    protected _addRetry(props?: RetryProps): void;
+    /**
+     * Add an error handler to the catch list of this state
+     * @internal
+     */
+    protected _addCatch(handler: State, props?: CatchProps): void;
+    /**
+     * Make the indicated state the default transition of this state
+     */
+    protected makeNext(next: State): void;
+    /**
+     * Add a choice branch to this state
+     */
+    protected addChoice(condition: Condition, next: State, options?: ChoiceTransitionOptions): void;
+    /**
+     * Add a parallel branch to this state
+     */
+    protected addBranch(branch: StateGraph): void;
+    /**
+     * Add a map iterator to this state
+     */
+    protected addIterator(iteration: StateGraph): void;
+    /**
+     * Add a item processor to this state
+     */
+    protected addItemProcessor(processor: StateGraph, config?: ProcessorConfig): void;
+    /**
+     * Make the indicated state the default choice transition of this state
+     */
+    protected makeDefault(def: State): void;
+    /**
+     * Render the default next state in ASL JSON format
+     */
+    protected renderNextEnd(): any;
+    /**
+     * Render the choices in ASL JSON format
+     */
+    protected renderChoices(topLevelQueryLanguage?: QueryLanguage): any;
+    /**
+     * Render InputPath/Parameters/OutputPath/Arguments/Output in ASL JSON format
+     */
+    protected renderInputOutput(): any;
+    /**
+     * Render parallel branches in ASL JSON format
+     */
+    protected renderBranches(): any;
+    /**
+     * Render map iterator in ASL JSON format
+     */
+    protected renderIterator(): any;
+    /**
+     * Render error recovery options in ASL JSON format
+     */
+    protected renderRetryCatch(topLevelQueryLanguage?: QueryLanguage): any;
+    /**
+     * Render ResultSelector in ASL JSON format
+     */
+    protected renderResultSelector(): any;
+    /**
+     * Render ItemProcessor in ASL JSON format
+     */
+    protected renderItemProcessor(): any;
+    /**
+     * Render ProcessorConfig in ASL JSON format
+     */
+    private renderProcessorConfig;
+    /**
+     * Render QueryLanguage in ASL JSON format if needed.
+     */
+    protected renderQueryLanguage(topLevelQueryLanguage?: QueryLanguage): any;
+    /**
+     * Render the assign in ASL JSON format
+     */
+    protected renderAssign(topLevelQueryLanguage?: QueryLanguage): any;
+    /**
+     * Called whenever this state is bound to a graph
+     *
+     * Can be overridden by subclasses.
+     */
+    protected whenBoundToGraph(graph: StateGraph): void;
+    /**
+     * Add a state to the incoming list
+     */
+    private addIncoming;
+    /**
+     * Return all states this state can transition to
+     */
+    private outgoingTransitions;
+}
+/**
+ * Options for finding reachable states
+ */
+export interface FindStateOptions {
+    /**
+     * Whether or not to follow error-handling transitions
+     *
+     * @default false
+     */
+    readonly includeErrorHandlers?: boolean;
+}
+/**
+ * Options for Choice Transition
+ */
+export interface ChoiceTransitionOptions extends AssignableStateOptions {
+    /**
+     * An optional description for the choice transition
+     *
+     * @default No comment
+     */
+    readonly comment?: string;
+    /**
+     * This option for JSONata only. When you use JSONPath, then the state ignores this property.
+     * Used to specify and transform output from the state.
+     * When specified, the value overrides the state output default.
+     * The output field accepts any JSON value (object, array, string, number, boolean, null).
+     * Any string value, including those inside objects or arrays,
+     * will be evaluated as JSONata if surrounded by {% %} characters.
+     * Output also accepts a JSONata expression directly.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-input-output-filtering.html
+     *
+     * @default - $states.result or $states.errorOutput
+     */
+    readonly outputs?: any;
+}
+/**
+ * Render a list or return undefined for an empty list
+ */
+export declare function renderList<T>(xs: T[], mapFn: (x: T) => any, sortFn?: (a: T, b: T) => number): any;
+/**
+ * Render JSON path, respecting the special value JsonPath.DISCARD
+ */
+export declare function renderJsonPath(jsonPath?: string): undefined | null | string;
+/**
+ * @internal
+ */
+export declare function _getActualQueryLanguage(topLevelQueryLanguage?: QueryLanguage, stateLevelQueryLanguage?: QueryLanguage): QueryLanguage;
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/succeed.d.ts

@@ -0,0 +1,45 @@
+import type { Construct } from 'constructs';
+import type { JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import type { INextable } from '../types';
+import { QueryLanguage } from '../types';
+/**
+ * Properties for defining a Succeed state that using JSONPath
+ */
+export interface SucceedJsonPathProps extends StateBaseProps, JsonPathCommonOptions {
+}
+/**
+ * Properties for defining a Succeed state that using JSONata
+ */
+export interface SucceedJsonataProps extends StateBaseProps, JsonataCommonOptions {
+}
+/**
+ * Properties for defining a Succeed state
+ */
+export interface SucceedProps extends StateBaseProps, JsonPathCommonOptions, JsonataCommonOptions {
+}
+/**
+ * Define a Succeed state in the state machine
+ *
+ * Reaching a Succeed state terminates the state execution in success.
+ */
+export declare class Succeed extends State {
+    /**
+     * Define a Succeed state in the state machine
+     *
+     * Reaching a Succeed state terminates the state execution in success.
+     */
+    static jsonPath(scope: Construct, id: string, props?: SucceedJsonPathProps): Succeed;
+    /**
+     * Define a Succeed state in the state machine
+     *
+     * Reaching a Succeed state terminates the state execution in success.
+     */
+    static jsonata(scope: Construct, id: string, props?: SucceedJsonataProps): Succeed;
+    readonly endStates: INextable[];
+    constructor(scope: Construct, id: string, props?: SucceedProps);
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(queryLanguage?: QueryLanguage): object;
+}

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/succeed.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Succeed=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class Succeed extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Succeed",version:"2.252.0"};static jsonPath(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_SucceedJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Succeed(scope,id,props)}static jsonata(scope,id,props={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_SucceedJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Succeed(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}endStates=[];constructor(scope,id,props={}){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_SucceedProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Succeed),error}}toStateJson(queryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(queryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{Type:state_type_1().StateType.SUCCEED,...this.renderQueryLanguage(queryLanguage),Comment:this.comment,...this.renderInputOutput()}}}exports.Succeed=Succeed;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/task-base.d.ts

@@ -0,0 +1,313 @@
+import type { Construct } from 'constructs';
+import type { AssignableStateOptions, JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import * as cloudwatch from '../../../aws-cloudwatch';
+import * as iam from '../../../aws-iam';
+import * as cdk from '../../../core';
+import { Chain } from '../chain';
+import type { StateGraph } from '../state-graph';
+import type { Credentials } from '../task-credentials';
+import type { CatchProps, IChainable, INextable, RetryProps } from '../types';
+import { QueryLanguage } from '../types';
+/**
+ * Base options for all task states
+ */
+export interface TaskStateBaseOptions {
+    /**
+     * Timeout for the task
+     *
+     * @default - None
+     * @deprecated use `taskTimeout`
+     */
+    readonly timeout?: cdk.Duration;
+    /**
+     * Timeout for the task
+     *
+     * [disable-awslint:duration-prop-type] is needed because all props interface in
+     * aws-stepfunctions-tasks extend this interface
+     *
+     * @default - None
+     */
+    readonly taskTimeout?: Timeout;
+    /**
+     * Timeout for the heartbeat
+     *
+     * @default - None
+     * @deprecated use `heartbeatTimeout`
+     */
+    readonly heartbeat?: cdk.Duration;
+    /**
+     * Timeout for the heartbeat
+     *
+     * [disable-awslint:duration-prop-type] is needed because all props interface in
+     * aws-stepfunctions-tasks extend this interface
+     *
+     * @default - None
+     */
+    readonly heartbeatTimeout?: Timeout;
+    /**
+     * AWS Step Functions integrates with services directly in the Amazon States Language.
+     * You can control these AWS services using service integration patterns.
+     *
+     * Depending on the AWS Service, the Service Integration Pattern availability will vary.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-supported-services.html
+     *
+     * @default - `IntegrationPattern.REQUEST_RESPONSE` for most tasks.
+     * `IntegrationPattern.RUN_JOB` for the following exceptions:
+     *  `BatchSubmitJob`, `EmrAddStep`, `EmrCreateCluster`, `EmrTerminationCluster`, and `EmrContainersStartJobRun`.
+     *
+     */
+    readonly integrationPattern?: IntegrationPattern;
+    /**
+     * Credentials for an IAM Role that the State Machine assumes for executing the task.
+     * This enables cross-account resource invocations.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/concepts-access-cross-acct-resources.html
+     *
+     * @default - None (Task is executed using the State Machine's execution role)
+     */
+    readonly credentials?: Credentials;
+}
+interface TaskStateJsonPathBaseOptions extends JsonPathCommonOptions {
+    /**
+     * JSONPath expression to indicate where to inject the state's output
+     *
+     * May also be the special value JsonPath.DISCARD, which will cause the state's
+     * input to become its output.
+     *
+     * @default $
+     */
+    readonly resultPath?: string;
+    /**
+     * The JSON that will replace the state's raw result and become the effective
+     * result before ResultPath is applied.
+     *
+     * You can use ResultSelector to create a payload with values that are static
+     * or selected from the state's raw result.
+     *
+     * @see
+     * https://docs.aws.amazon.com/step-functions/latest/dg/input-output-inputpath-params.html#input-output-resultselector
+     *
+     * @default - None
+     */
+    readonly resultSelector?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Props that are common to all tasks that using JSONPath
+ */
+export interface TaskStateJsonPathBaseProps extends StateBaseProps, TaskStateBaseOptions, AssignableStateOptions, TaskStateJsonPathBaseOptions {
+}
+/**
+ * Props that are common to all tasks that using JSONata
+ */
+export interface TaskStateJsonataBaseProps extends StateBaseProps, TaskStateBaseOptions, AssignableStateOptions, JsonataCommonOptions {
+}
+/**
+ * Props that are common to all tasks
+ */
+export interface TaskStateBaseProps extends StateBaseProps, TaskStateBaseOptions, AssignableStateOptions, TaskStateJsonPathBaseOptions, JsonataCommonOptions {
+}
+/**
+ * Define a Task state in the state machine
+ *
+ * Reaching a Task state causes some work to be executed, represented by the
+ * Task's resource property. Task constructs represent a generic Amazon
+ * States Language Task.
+ *
+ * For some resource types, more specific subclasses of Task may be available
+ * which are more convenient to use.
+ */
+export declare abstract class TaskStateBase extends State implements INextable {
+    readonly endStates: INextable[];
+    protected abstract readonly taskMetrics?: TaskMetricsConfig;
+    protected abstract readonly taskPolicies?: iam.PolicyStatement[];
+    private readonly timeout?;
+    private readonly taskTimeout?;
+    private readonly heartbeat?;
+    private readonly heartbeatTimeout?;
+    private readonly credentials?;
+    constructor(scope: Construct, id: string, props: TaskStateBaseProps);
+    /**
+     * Add retry configuration for this state
+     *
+     * This controls if and how the execution will be retried if a particular
+     * error occurs.
+     */
+    addRetry(props?: RetryProps): TaskStateBase;
+    /**
+     * Add a recovery handler for this state
+     *
+     * When a particular error occurs, execution will continue at the error
+     * handler instead of failing the state machine execution.
+     */
+    addCatch(handler: IChainable, props?: CatchProps): TaskStateBase;
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(topLevelQueryLanguage?: QueryLanguage): object;
+    /**
+     * Return the given named metric for this Task
+     *
+     * @default - sum over 5 minutes
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The interval, in milliseconds, between the time the Task starts and the time it closes.
+     *
+     * @default - average over 5 minutes
+     */
+    metricRunTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The interval, in milliseconds, for which the activity stays in the schedule state.
+     *
+     * @default - average over 5 minutes
+     */
+    metricScheduleTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The interval, in milliseconds, between the time the activity is scheduled and the time it closes.
+     *
+     * @default - average over 5 minutes
+     */
+    metricTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the number of times this activity is scheduled
+     *
+     * @default - sum over 5 minutes
+     */
+    metricScheduled(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the number of times this activity times out
+     *
+     * @default - sum over 5 minutes
+     */
+    metricTimedOut(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the number of times this activity is started
+     *
+     * @default - sum over 5 minutes
+     */
+    metricStarted(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the number of times this activity succeeds
+     *
+     * @default - sum over 5 minutes
+     */
+    metricSucceeded(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the number of times this activity fails
+     *
+     * @default - sum over 5 minutes
+     */
+    metricFailed(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the number of times the heartbeat times out for this activity
+     *
+     * @default - sum over 5 minutes
+     */
+    metricHeartbeatTimedOut(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    protected whenBoundToGraph(graph: StateGraph): void;
+    /**
+     * @internal
+     */
+    protected abstract _renderTask(topLevelQueryLanguage?: QueryLanguage): any;
+    /**
+     * @internal
+     */
+    protected _renderParametersOrArguments(paramOrArg: any, queryLanguage: QueryLanguage): any;
+    private taskMetric;
+    private renderCredentials;
+    private renderTaskBase;
+}
+/**
+ * Task Metrics
+ */
+export interface TaskMetricsConfig {
+    /**
+     * Prefix for singular metric names of activity actions
+     *
+     * @default - No such metrics
+     */
+    readonly metricPrefixSingular?: string;
+    /**
+     * Prefix for plural metric names of activity actions
+     *
+     * @default - No such metrics
+     */
+    readonly metricPrefixPlural?: string;
+    /**
+     * The dimensions to attach to metrics
+     *
+     * @default - No metrics
+     */
+    readonly metricDimensions?: cloudwatch.DimensionHash;
+}
+/**
+ *
+ * AWS Step Functions integrates with services directly in the Amazon States Language.
+ * You can control these AWS services using service integration patterns:
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html
+ *
+ */
+export declare enum IntegrationPattern {
+    /**
+     * Step Functions will wait for an HTTP response and then progress to the next state.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default
+     */
+    REQUEST_RESPONSE = "REQUEST_RESPONSE",
+    /**
+     * Step Functions can wait for a request to complete before progressing to the next state.
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync
+     */
+    RUN_JOB = "RUN_JOB",
+    /**
+     * Callback tasks provide a way to pause a workflow until a task token is returned.
+     * You must set a task token when using the callback pattern
+     *
+     * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token
+     */
+    WAIT_FOR_TASK_TOKEN = "WAIT_FOR_TASK_TOKEN"
+}
+/**
+ * Timeout for a task or heartbeat
+ */
+export declare abstract class Timeout {
+    /**
+     * Use a duration as timeout
+     */
+    static duration(duration: cdk.Duration): Timeout;
+    /**
+     * Use a dynamic timeout specified by a JSONata expression.
+     *
+     * The JSONata expression value must be a positive integer.
+     */
+    static jsonata(jsonataExpression: string): Timeout;
+    /**
+     * Use a dynamic timeout specified by a path in the state input.
+     *
+     * The path must select a field whose value is a positive integer.
+     */
+    static at(path: string): Timeout;
+    /**
+     * Seconds for this timeout
+     */
+    abstract readonly seconds?: number;
+    /**
+     * JSONata expression for this timeout
+     */
+    abstract readonly jsonataExpression?: string;
+    /**
+     * Path for this timeout
+     */
+    abstract readonly path?: string;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/task.d.ts

@@ -0,0 +1,8 @@
+import type { Construct } from 'constructs';
+import { State } from './state';
+import * as cloudwatch from '../../../aws-cloudwatch';
+import * as cdk from '../../../core';
+import { Chain } from '../chain';
+import type { StateGraph } from '../state-graph';
+import '../step-functions-task';
+import type { CatchProps, IChainable, INextable, QueryLanguage, RetryProps } from '../types';

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/task.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Task=void 0;const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},cloudwatch=()=>{var tmp=require("../../../aws-cloudwatch");return cloudwatch=()=>tmp,tmp},cdk=()=>{var tmp=require("../../../core");return cdk=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp},chain_1=()=>{var tmp=require("../chain");return chain_1=()=>tmp,tmp},fields_1=()=>{var tmp=require("../fields");return fields_1=()=>tmp,tmp},util_1=()=>{var tmp=require("../private/util");return util_1=()=>tmp,tmp};class Task extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Task",version:"2.252.0"};endStates;timeout;taskProps;constructor(scope,id,props){super(scope,id,props),this.timeout=props.timeout;const taskProps=props.task.bind(this);this.taskProps={...taskProps,parameters:(0,util_1().noEmptyObject)({...taskProps.parameters||{},...props.parameters||{}})},this.endStates=[this]}addRetry(props={}){return super._addRetry(props),this}addCatch(handler,props={}){return super._addCatch(handler.startState,props),this}next(next){return super.makeNext(next.startState),chain_1().Chain.sequence(this,next)}toStateJson(_){return{...this.renderNextEnd(),...this.renderRetryCatch(),...this.renderInputOutput(),Type:state_type_1().StateType.TASK,Comment:this.comment,Resource:this.taskProps.resourceArn,Parameters:this.taskProps.parameters&&fields_1().FieldUtils.renderObject(this.taskProps.parameters),ResultPath:(0,state_1().renderJsonPath)(this.resultPath),TimeoutSeconds:this.timeout&&this.timeout.toSeconds(),HeartbeatSeconds:this.taskProps.heartbeat&&this.taskProps.heartbeat.toSeconds()}}metric(metricName,props){return new(cloudwatch()).Metric({namespace:"AWS/States",metricName,dimensions:this.taskProps.metricDimensions,statistic:"sum",...props}).attachTo(this)}metricRunTime(props){return this.taskMetric(this.taskProps.metricPrefixSingular,"RunTime",{statistic:"avg",...props})}metricScheduleTime(props){return this.taskMetric(this.taskProps.metricPrefixSingular,"ScheduleTime",{statistic:"avg",...props})}metricTime(props){return this.taskMetric(this.taskProps.metricPrefixSingular,"Time",{statistic:"avg",...props})}metricScheduled(props){return this.taskMetric(this.taskProps.metricPrefixPlural,"Scheduled",props)}metricTimedOut(props){return this.taskMetric(this.taskProps.metricPrefixPlural,"TimedOut",props)}metricStarted(props){return this.taskMetric(this.taskProps.metricPrefixPlural,"Started",props)}metricSucceeded(props){return this.taskMetric(this.taskProps.metricPrefixPlural,"Succeeded",props)}metricFailed(props){return this.taskMetric(this.taskProps.metricPrefixPlural,"Failed",props)}metricHeartbeatTimedOut(props){return this.taskMetric(this.taskProps.metricPrefixPlural,"HeartbeatTimedOut",props)}whenBoundToGraph(graph){super.whenBoundToGraph(graph);for(const policyStatement of this.taskProps.policyStatements||[])graph.registerPolicyStatement(policyStatement)}taskMetric(prefix,suffix,props){if(prefix===void 0)throw new(cdk()).UnscopedValidationError((0,literal_string_1().lit)`TaskResourceDoesNotExposeMetrics`,"This Task Resource does not expose metrics");return this.metric(prefix+suffix,props)}}exports.Task=Task;

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/wait.d.ts

@@ -0,0 +1,103 @@
+import type { Construct } from 'constructs';
+import type { AssignableStateOptions, JsonataCommonOptions, JsonPathCommonOptions, StateBaseProps } from './state';
+import { State } from './state';
+import type * as cdk from '../../../core';
+import { Chain } from '../chain';
+import type { IChainable, INextable } from '../types';
+import { QueryLanguage } from '../types';
+/**
+ * Represents the Wait state which delays a state machine from continuing for a specified time
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-wait-state.html
+ */
+export declare class WaitTime {
+    private readonly json;
+    /**
+     * Wait a fixed amount of time.
+     */
+    static duration(duration: cdk.Duration): WaitTime;
+    /**
+     * Wait for a number of seconds stored in the state object from string.
+     * This method can use JSONata expression.
+     *
+     * If you want to use fixed value, we recommend using `WaitTime.duration()`
+     *
+     * Example value: `{% $waitSeconds %}`
+     */
+    static seconds(seconds: string): WaitTime;
+    /**
+     * Wait until the given ISO8601 timestamp.
+     * This method can use JSONata expression.
+     *
+     * Example value: `2016-03-14T01:59:00Z`
+     */
+    static timestamp(timestamp: string): WaitTime;
+    /**
+     * Wait for a number of seconds stored in the state object.
+     *
+     * Example value: `$.waitSeconds`
+     */
+    static secondsPath(path: string): WaitTime;
+    /**
+     * Wait until a timestamp found in the state object.
+     *
+     * Example value: `$.waitTimestamp`
+     */
+    static timestampPath(path: string): WaitTime;
+    private constructor();
+    /**
+     * @internal
+     */
+    get _json(): any;
+}
+interface WaitOptions {
+    /**
+     * Wait duration.
+     */
+    readonly time: WaitTime;
+}
+/**
+ * Properties for defining a Wait state that using JSONPath
+ */
+export interface WaitJsonPathProps extends StateBaseProps, AssignableStateOptions, WaitOptions, JsonPathCommonOptions {
+}
+/**
+ * Properties for defining a Wait state that using JSONata
+ */
+export interface WaitJsonataProps extends StateBaseProps, AssignableStateOptions, WaitOptions, JsonataCommonOptions {
+}
+/**
+ * Properties for defining a Wait state
+ */
+export interface WaitProps extends StateBaseProps, AssignableStateOptions, WaitOptions {
+}
+/**
+ * Define a Wait state in the state machine
+ *
+ * A Wait state can be used to delay execution of the state machine for a while.
+ */
+export declare class Wait extends State implements INextable {
+    /**
+     * Define a Wait state using JSONPath in the state machine
+     *
+     * A Wait state can be used to delay execution of the state machine for a while.
+     */
+    static jsonPath(scope: Construct, id: string, props: WaitJsonPathProps): Wait;
+    /**
+     * Define a Wait state using JSONata in the state machine
+     *
+     * A Wait state can be used to delay execution of the state machine for a while.
+     */
+    static jsonata(scope: Construct, id: string, props: WaitJsonataProps): Wait;
+    readonly endStates: INextable[];
+    private readonly time;
+    constructor(scope: Construct, id: string, props: WaitProps);
+    /**
+     * Continue normal execution with the given state
+     */
+    next(next: IChainable): Chain;
+    /**
+     * Return the Amazon States Language object for this state
+     */
+    toStateJson(topLevelQueryLanguage?: QueryLanguage): object;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-stepfunctions/lib/states/wait.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Wait=exports.WaitTime=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var state_type_1=()=>{var tmp=require("./private/state-type");return state_type_1=()=>tmp,tmp},state_1=()=>{var tmp=require("./state");return state_1=()=>tmp,tmp},chain_1=()=>{var tmp=require("../chain");return chain_1=()=>tmp,tmp},types_1=()=>{var tmp=require("../types");return types_1=()=>tmp,tmp};class WaitTime{json;static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.WaitTime",version:"2.252.0"};static duration(duration){try{jsiiDeprecationWarnings().aws_cdk_lib_Duration(duration)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.duration),error}return new WaitTime({Seconds:duration.toSeconds()})}static seconds(seconds){return new WaitTime({Seconds:seconds})}static timestamp(timestamp){return new WaitTime({Timestamp:timestamp})}static secondsPath(path){return new WaitTime({SecondsPath:path})}static timestampPath(path){return new WaitTime({TimestampPath:path})}constructor(json){this.json=json}get _json(){return this.json}}exports.WaitTime=WaitTime;class Wait extends state_1().State{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_stepfunctions.Wait",version:"2.252.0"};static jsonPath(scope,id,props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_WaitJsonPathProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonPath),error}return new Wait(scope,id,props)}static jsonata(scope,id,props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_WaitJsonataProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.jsonata),error}return new Wait(scope,id,{...props,queryLanguage:types_1().QueryLanguage.JSONATA})}endStates;time;constructor(scope,id,props){super(scope,id,props);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_WaitProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Wait),error}this.time=props.time,this.endStates=[this]}next(next){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_IChainable(next)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.next),error}return super.makeNext(next.startState),chain_1().Chain.sequence(this,next)}toStateJson(topLevelQueryLanguage){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_stepfunctions_QueryLanguage(topLevelQueryLanguage)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.toStateJson),error}return{Type:state_type_1().StateType.WAIT,...this.renderQueryLanguage(topLevelQueryLanguage),Comment:this.comment,...this.time._json,...this.renderInputOutput(),...this.renderNextEnd(),...this.renderAssign(topLevelQueryLanguage)}}}exports.Wait=Wait;