Amazon States Language

https://states-language.net
Admin
This document describes the Amazon States Language, a JSON-based language used to declaratively...
Tokens:18,182
Snippets:214
Trust Score:8.2
Update:3 months ago
Show doc for...
Tokens:
Raw
### Task State Example

Source: https://states-language.net/

A basic example of a Task State, including its type, resource, and next state.

```json
"TaskState": {
  "Comment": "Task State example",
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:task:HelloWorld",
  "Next": "NextState",
  "TimeoutSeconds": 300,
  "HeartbeatSeconds": 60
}
```

--------------------------------

### JSONPath Pass State Input Example

Source: https://states-language.net/

Example input for a JSONPath Pass State.

```json
{
  "georefOf": "Home"
}
```

--------------------------------

### JSONPath Choice State Input Example

Source: https://states-language.net/

Provides an example input JSON for a JSONPath Choice State. This input is used to demonstrate how conditions are evaluated.

```json
{
  "type": "Private",
  "value": 22
}
```

--------------------------------

### Example JSONPath Query Results

Source: https://states-language.net/

Demonstrates the results of applying simple JSONPath queries to the example JSON data.

```json
$.foo => 123
$.bar => ["a", "b", "c"]
$.car.cdr => true

```

--------------------------------

### Example JSON Input Data

Source: https://states-language.net/

This JSON object serves as an example input for demonstrating JSONPath queries.

```json
{
  "foo": 123,
  "bar": ["a", "b", "c"],
  "car": {
      "cdr": true
  }
}

```

--------------------------------

### Example Input for Nested ResultPath

Source: https://states-language.net/

A simple input object for a Task State.

```json
{
  "a": 1
}
```

--------------------------------

### Example Output with ResultPath

Source: https://states-language.net/

The output structure after applying InputPath to select '$.numbers' and ResultPath to place the result under '$.sum'.

```json
{
  "title": "Numbers to add",
  "numbers": { "val1": 3, "val2": 4 },
  "sum": 7
}
```

--------------------------------

### JSONPath Pass State Output Example

Source: https://states-language.net/

Example output from a JSONPath Pass State after processing the input.

```json
{
  "georefOf": "Home",
  "coords": {
    "x-datum": 0.381018,
    "y-datum": 622.2269926397355
  }
}
```

--------------------------------

### Map State Example

Source: https://states-language.net/

This example demonstrates a Map State that processes each element of the 'shipped' array using a Lambda function named 'ship-val'. It specifies the ItemProcessor, ItemsPath, and MaxConcurrency.

```json
{
  "Type": "Map",
  "ItemProcessor": {
    "Type": "Task",
    "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ship-val",
    "Parameters": {
      "detail.$": "$"
    }
  },
  "ItemsPath": "detail.shipped",
  "MaxConcurrency": 1000,
  "ResultPath": null
}
```

--------------------------------

### JSONPath Choice State Example

Source: https://states-language.net/

Illustrates a Choice State using JSONPath for conditions. Suitable for simpler path-based data comparisons and checks.

```json
{
  "DispatchEvent": {
    "Type" : "Choice",
    "Choices": [
      {
        "Not": {
          "Variable": "$.type",
          "StringEquals": "Private"
        },
        "Next": "Public"
      },
      {
        "And": [
          {
            "Variable": "$.value",
            "IsPresent": true
          },
          {
            "Variable": "$.value",
            "IsNumeric": true
          },
          {
            "Variable": "$.value",
            "NumericGreaterThanEquals": 20
          },
          {
            "Variable": "$.value",
            "NumericLessThan": 30
          }
        ],
        "Assign": {
          "range": "twenties"
        },
        "Next": "ValueInTwenties"
      },
      {
        "Variable": "$.rating",
        "NumericGreaterThanPath": "$.auditThreshold",
        "Next": "StartAudit"
      }
    ],
    "Default": "RecordEvent",
    "Assign": {
      "range": "default"
    }
  }
}
```

--------------------------------

### Example Input for Lambda Task

Source: https://states-language.net/

This is the input structure for a Lambda task that sums two numbers.

```json
{
  "title": "Numbers to add",
  "numbers": { "val1": 3, "val2": 4 }
}
```

--------------------------------

### Example Input Payload

Source: https://states-language.net/

The input JSON object provided to the state machine execution.

```json
{
  "flagged": 7,
  "vals": [0, 10, 20, 30, 40, 50]
}

```

--------------------------------

### Example Output with Nested ResultPath

Source: https://states-language.net/

The output structure when ResultPath is used to create nested JSON objects.

```json
{
  "a": 1,
  "b": {
    "greeting": "Hi!"
  }
}
```

--------------------------------

### Acceptable Reference Path Syntax Examples

Source: https://states-language.net/

Illustrates various valid syntaxes for Reference Paths in JSONPath, including escaped characters and array indexing.

```json
$.store.book
$.store\.book
$.\stor\e.boo\k
$.store.book.title
$.foo.\.bar
$.foo@bar.baz[[.?pretty
$.&Ж中.\uD800\uDF46
$.ledgers.branch[0].pending.count
$.ledgers.branch[0]
$.ledgers[0][22][315].foo
$['store']['book']
$['store'][0]['book']

```

--------------------------------

### Parallel State Output Example

Source: https://states-language.net/

Illustrates the output format of a Parallel State when branches perform mathematical operations. The output is an array where each element corresponds to the result of a branch.

```json
[
  5,
  1
]

```

--------------------------------

### Example Context Object

Source: https://states-language.net/

The context object available during state machine execution, containing metadata like the day of the week.

```json
{
  "DayOfWeek": "TUESDAY"
}

```

--------------------------------

### Minimal Hello World State Machine

Source: https://states-language.net/

A basic state machine with a single Task state that ends execution. This serves as a minimal example for defining a state machine.

```json
{
  "Comment": "A simple minimal example of the States language",
  "StartAt": "Hello World",
  "States": {
    "Hello World": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorld",
      "End": true
    }
  }
}
```

--------------------------------

### Parallel State Example - Customer Info Lookup

Source: https://states-language.net/

This Parallel State defines two branches: one to look up customer address and another to look up the phone number. Execution proceeds to 'NextState' only after both branches complete.

```json
"LookupCustomerInfo": {
  "Type": "Parallel",
  "Branches": [
    {
      "StartAt": "LookupAddress",
      "States": {
        "LookupAddress": {
          "Type": "Task",
          "Resource": "arn:aws:lambda:us-east-1:123456789012:function:AddressFinder",
          "End": true
        }
      }
    },
    {
      "StartAt": "LookupPhone",
      "States": {
        "LookupPhone": {
          "Type": "Task",
          "Resource": "arn:aws:lambda:us-east-1:123456789012:function:PhoneFinder",
          "End": true
        }
      }
    }
  ],
  "Next": "NextState"
}

```

--------------------------------

### Example of ResultPath Runtime Error

Source: https://states-language.net/

This scenario demonstrates a ResultPath runtime error when the path does not match the input type.

```json
$.x
```

--------------------------------

### JSONata Map State Input Example

Source: https://states-language.net/

Illustrates the input structure for a single iteration of a JSONata Map State, containing details for a parcel and its destination.

```json
{
  "prod": "R31",
  "dest-code": 9511,
  "quantity": 1344
}

```

--------------------------------

### Define a Task State in States Language

Source: https://states-language.net/

This example shows the structure of a 'Task' state, which executes a specified resource like a Lambda function. It includes fields for type, resource ARN, and the next state in the workflow.

```json
"HelloWorld": {
  "Type": "Task",
  "QueryLanguage": "JSONPath",
  "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorld",
  "Next": "NextState",
  "Comment": "Executes the HelloWorld Lambda function"
}
```

--------------------------------

### JSONata Choice State Example

Source: https://states-language.net/

Demonstrates a Choice State using JSONata for conditions. Use when complex data manipulation or non-standard comparisons are needed within conditions.

```json
{
  "DispatchEvent": {
    "Type" : "Choice",
    "QueryLanguage": "JSONata",
    "Choices": [
      {
        "Condition": "{% $states.input.type != 'Private' %}",
        "Next": "Public"
      },
      {
        "Condition": "{% $exists($value) and $type($value)='number' and $value>=20 and $value<30 %}",
        "Assign": {
          "range": "twenties"
        },
        "Next": "ValueInTwenties"
      },
      {
        "Condition": "{% $states.input.rating >= $states.input.auditThreshold %}",
        "Output": {
          "excess": "{% $states.input.rating - $states.input.auditThreshold %}"
        },
        "Next": "StartAudit"
      }
    ],
    "Default": "RecordEvent",
    "Assign": {
      "range": "default"
    }
  }
}
```

--------------------------------

### JSONata Undefined Result Example

Source: https://states-language.net/

This example highlights a JSONata expression that fails to return a result because it references a non-existent field. JSON cannot represent an undefined value, leading to an error.

```json
"{% $data.thisFieldDoesNotExist %}"
```

--------------------------------

### JSONPath Example with Multiple Values

Source: https://states-language.net/

When a JSONPath expression yields multiple values, they are gathered into a JSON array for the state's input or output.

```json
{
  "a": [1, 2, 3, 4]
}
```

```json
[
  1,
  2
]
```

--------------------------------

### Task State with JSONata Output and Catch

Source: https://states-language.net/

Illustrates a Task state configuration using JSONata for its 'Output' and 'Catch' fields. This example demonstrates how to conditionally structure output based on success or error using JSONata and the 'states' variable.

```JSON
{
  "My Task": {
    "Type": "Task",
    "QueryLanguage": "JSONata",
    "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorld",
    "Output": {
      "customer": "{% $states.input.customer %}",
      "resultStatus": "{% $states.result.status %}",
      "elapsedTime": "{% $states.context.ElapsedTime %}"
    },
    "Catch": [
      {
        "ErrorEquals": ["States.ALL"],
        "Output": {
          "errorDetails": "{% $states.errorOutput %}",
          "input": "{% $states.input %}"
        },
        "Next": "Handle Error"
      }
    ],
    "End": true
  }
}
```

--------------------------------

### Parallel State Example - Math Operations

Source: https://states-language.net/

This Parallel State executes 'Add' and 'Subtract' tasks concurrently. The output of the Parallel State will be a JSON array containing the results of each branch.

```json
"FunWithMath": {
  "Type": "Parallel",
  "Branches": [
    {
      "StartAt": "Add",
      "States": {
        "Add": {
          "Type": "Task",
          "Resource": "arn:aws:states:::task:Add",
          "End": true
        }
      }
    },
    {
      "StartAt": "Subtract",
      "States": {
        "Subtract": {
          "Type": "Task",
          "Resource": "arn:aws:states:::task:Subtract",
          "End": true
        }
      }
    }
  ],
  "Next": "NextState"
}

```

--------------------------------

### Assigning Variables with JSONata

Source: https://states-language.net/

This example shows how to assign variables in a Pass state. JSONata expressions can be used to define complex data structures.

```json
{
  "GetSampleData": {
    "Type": "Pass",
    "Assign": {
      "student": {
        "name": "Scotland",
        "course": [
          { "grade": 34 },
          { "grade": 99 },
          { "grade": 76 },
          { "grade": 96 }
        ]
      },
      "class": {
        "teacher": "Bert"
      },
      "two": "the number 2"
    },
    "Next": "A Task"
  }
}
```

--------------------------------

### Using States.Format Intrinsic Function

Source: https://states-language.net/

This example demonstrates how to use the 'States.Format' intrinsic function to construct a greeting string using input data. Ensure that any special characters within the format string are properly escaped.

```json
"X": {
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:task:X",
  "Next": "Y",
  "Parameters": {
    "greeting.$": "States.Format('Welcome to {} {}\'s playlist.', $.firstName, $.lastName)"
  }
}

```

--------------------------------

### Define a Simple State Machine in States Language

Source: https://states-language.net/

This defines a basic state machine with a single 'Task' state named 'Add' that transitions to the end of the execution. It specifies the starting state and the states object.

```json
{
  "StartAt": "Add",
  "States": {
    "Add": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Add",
      "End": true
    }
  }
}
```

--------------------------------

### JSONata Pass State Example

Source: https://states-language.net/

This Pass State uses the 'Assign' field with JSONata to provide fixed test data. The 'QueryLanguage' is set to 'JSONata'.

```json
"ProvideTestData": {
  "Type": "Pass",
  "QueryLanguage": "JSONata",
  "Assign": {
    "coords": {
      "x-datum": 0.381018,
      "y-datum": 622.2269926397355,
      "additional": "{% $exists($states.input.moreData) ? $states.input.moreData : {} %}"
    }
  },
  "Next": "End"
}
```

--------------------------------

### JSONPath Pass State Example

Source: https://states-language.net/

This Pass State uses the 'Result' and 'ResultPath' fields to inject fixed data into the state machine's output. If 'Result' or 'ResultPath' are not provided, the input is passed through.

```json
"ProvideTestData": {
  "Type": "Pass",
  "Result": {
    "x-datum": 0.381018,
    "y-datum": 622.2269926397355
  },
  "ResultPath": "$.coords",
  "Next": "End"
}
```

--------------------------------

### Get Array Length

Source: https://states-language.net/

Use States.ArrayLength to determine the number of elements in an array. Pass the array as the single argument to this function.

```json
{ "inputArray": [1,2,3,4,5,6,7,8,9] }
```

```json
{ "length.$": "States.ArrayLength($.inputArray)" }
```

```json
{ "length": 9 }
```

--------------------------------

### Referencing Variables with JSONata

Source: https://states-language.net/

Reference assigned variables in the 'Output' field using JSONata syntax (prepending with '$'). The example demonstrates constructing a string using previously assigned variables. Variable assignments take effect in the next state.

```json
{
  "SecondState": {
    "Type": "Pass",
    "QueryLanguage": "JSONata",
    "Output": "{% $year & ' ' & $make & ' ' & $model %}",
    "Next": "ThirdState"
  }

}
```

--------------------------------

### Referencing Variables in Arguments and Output with JSONata

Source: https://states-language.net/

This example demonstrates referencing previously assigned variables within the Arguments and Output fields of a Task state using JSONata expressions. The interpreter evaluates these expressions to construct the input for a Lambda function and to define the state's output.

```json
{
  "A Task": {
    "Type": "Task",
    "QueryLanguage": "JSONata",
    "Resource": "arn:aws:lambda:us-east-1:123456789012:function:DoTheTask",
    "Arguments": {
      "student": "{% $student.name %}",
      "classInfo": {
        "teacher": "{% $class.teacher %}"
      },
      "values": [ 1, "{% $two %}", "three" ]
    },
    "Output": "{% { 'avg': $average($student.course.grade), 'num': $count($student.course) }  %}",
    "Next": "Process the result"
  }
}
```

--------------------------------

### JSONata Type Mismatch Example

Source: https://states-language.net/

Demonstrates a JSONata expression evaluating to a type incompatible with the target field. For instance, assigning a string to 'TimeoutSeconds' which expects a number.

```json
"TimeoutSeconds": "{% $name %}"
```

--------------------------------

### Set Default Query Language for State Machine

Source: https://states-language.net/

Use the top-level 'QueryLanguage' field to set the default query language for all states in the state machine. This example sets the default to JSONata.

```json
{
  "QueryLanguage": "JSONata",
  "StartAt": "Hello World",
  "States": {
    "Hello World": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorld",
      "End": true
    }
  }
}
```

--------------------------------

### JSONata Map State ItemSelector Output Example

Source: https://states-language.net/

Shows the structured input for a single iteration when using 'ItemSelector' in a JSONata Map State, including parcel and courier details.

```json
{
  "parcel": {
    "prod": "R31",
    "dest-code": 9511,
    "quantity": 1344
   },
   "courier": "UQS"
}

```

--------------------------------

### Get Array Item by Index

Source: https://states-language.net/

Use States.ArrayGetItem to retrieve a value from an array at a specific index. The second argument is the zero-based index of the desired element.

```json
{ "inputArray": [1,2,3,4,5,6,7,8,9], "index": 5 }
```

```json
{ "item.$": "States.ArrayGetItem($.inputArray, $.index)" }
```

```json
{ "item": 6 }
```

--------------------------------

### Lambda Function for Adding Numbers

Source: https://states-language.net/

A JavaScript example of a Lambda function handler that takes two numbers from the input event and returns their sum. This function is intended to be used as a 'Resource' in a States Language 'Task' state.

```javascript
export const handler = async (event) => {
  return event.val1 + event.val2;
};
```

--------------------------------

### JSONPath Catchers Example

Source: https://states-language.net/

Illustrates Catchers for JSONPath states. The first Catcher targets Java exceptions, injecting the Error Output into the original input at '$.error-info'. The second Catcher handles all other errors, assigning 'true' to 'hasError' before transitioning.

```json
"Catch": [
  {
    "ErrorEquals": [ "java.lang.Exception" ],
    "ResultPath": "$.error-info",
    "Next": "RecoveryState"
  },
  {
    "ErrorEquals": [ "States.ALL" ],
    "Assign": {
      "hasError": true
    },
    "Next": "EndMachine"
  }
]
```

--------------------------------

### JSONata Catchers Example

Source: https://states-language.net/

Defines Catchers for JSONata states. The first Catcher handles specific Java exceptions, merging original input with error info. The second Catcher acts as a wildcard, assigning a boolean to 'isCritical' based on the error message before transitioning.

```json
"Catch": [
  {
    "ErrorEquals": [ "java.lang.Exception" ],
    "Output": "{%% $merge([ $states.input, {'error-info': $states.errorOutput} ]) %%}",
    "Next": "RecoveryState"
  },
  {
    "ErrorEquals": [ "States.ALL" ],
    "Assign": {
      "isCritical": "{%% $contains($lowercase($states.errorOutput.Error), /.*fatal.*/)  %%}"
    },
    "Next": "EndMachine"
  }
]
```

--------------------------------

### JSONata Type Error Example

Source: https://states-language.net/

Illustrates a potential JSONata type error where an arithmetic operation is attempted on non-numeric types. This would result in a 'States.QueryEvaluationError'.

```json
"{% $x + $y %}"
```

--------------------------------

### Basic Task State with Payload Template

Source: https://states-language.net/

A simple Task State demonstrating a static Payload Template. The 'Parameters' field directly defines the input structure for the task.

```json
"X": {
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:task:X",
  "Next": "Y",
  "Parameters": {
    "first": 88,
    "second": 99
  }
}

```

--------------------------------

### Using States.Format Intrinsic Function

Source: https://states-language.net/

Demonstrates how to use the States.Format intrinsic function to construct strings by embedding values from the input payload. Ensure the number of '{}' placeholders matches the number of arguments.

```json
{
  "Parameters": {
    "foo.$": "States.Format('Your name is {}, we are in the year {}', $.name, 2020)"
  }
}
```

--------------------------------

### Retry Policy with Wildcard Error and No Retries

Source: https://states-language.net/

Sets up a policy to retry specific errors a maximum of 0 times and all other errors with default parameters.

```json
"Retry" : [
  {
    "ErrorEquals": [ "States.Timeout" ],
    "MaxAttempts": 0
  },
  {
    "ErrorEquals": [ "States.ALL" ]
  }
]
```

--------------------------------

### JSONPath Map State with ItemSelector

Source: https://states-language.net/

Demonstrates using 'ItemSelector' with JSONPath to construct complex inputs for each iteration, combining item values with other context data.

```json
"Validate-All": {
  "Type": "Map",
  "InputPath": "$.detail",
  "ItemsPath": "$.shipped",
  "MaxConcurrency": 0,
  "ItemSelector": {
    "parcel.$": "$$.Map.Item.Value",
    "courier.$": "$.delivery-partner"
  },
  "ItemProcessor": {
    "StartAt": "Validate",
    "States": {
      "Validate": {
        "Type": "Task",
        "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ship-val",
        "End": true
      }
    }
  },
  "ResultPath": "$.detail.shipped",
  "End": true
}

```

--------------------------------

### JSONata Value Constraint Violation Example

Source: https://states-language.net/

Shows a JSONata expression returning a value that violates field constraints. Here, a negative number is returned for 'ToleratedFailurePercentage', which requires a value between 0 and 100.

```json
"ToleratedFailurePercentage": "{% $negative %}"
```

--------------------------------

### Retry Policy with Jitter Strategy

Source: https://states-language.net/

Implements a retry policy using a custom 'SAMPLE' jitter strategy to vary retry intervals.

```json
"Retry" : [
  {
    "ErrorEquals": [ "States.Timeout" ],
    "IntervalSeconds": 2,
    "MaxAttempts": 2,
    "BackoffRate": 2.0,
    "JitterStrategy": "SAMPLE"
  }
]
```

--------------------------------

### Using States.Array Intrinsic Function

Source: https://states-language.net/

Demonstrates the creation of a JSON array using the States.Array intrinsic function. It can take zero or more arguments, including values from the input payload.

```json
{
  "Parameters": {
    "foo.$": "States.Array('Foo', 2020, $.someJson, null)"
  }
}
```

--------------------------------

### Wait State with Seconds

Source: https://states-language.net/

Introduces a delay into a state machine by specifying the duration in seconds. Ensure 'Next' is defined for subsequent states.

```json
"wait_ten_seconds" : {
  "Type" : "Wait",
  "Seconds" : 10,
  "Next": "NextState"
}
```

--------------------------------

### ResultPath Creating New Fields

Source: https://states-language.net/

Illustrates how ResultPath creates new fields and intervening objects when the target path does not exist in the raw input.

```json
{
  "master": {
    "detail": [1, 2, 3]
  }
}
```

```json
{
  "master": {
    "detail": [
      1,
      2,
      3
    ],
    "result": {
      "sum": 6
    }
  }
}
```

--------------------------------

### Complex Retry Scenario in Task State

Source: https://states-language.net/

Illustrates a Task State with multiple retry conditions for different error types and a catch block.

```json
"X": {
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:task:X",
  "Next": "Y",
  "Retry": [
    {
      "ErrorEquals": [ "ErrorA", "ErrorB" ],
      "IntervalSeconds": 1,
      "BackoffRate": 2,
      "MaxAttempts": 2
    },
    {
      "ErrorEquals": [ "ErrorC" ],
      "IntervalSeconds": 5
    }
  ],
  "Catch": [
    {
      "ErrorEquals": [ "States.ALL" ],
      "Next": "Z"
    }
  ]
}
```

--------------------------------

### Variable Assignment and Referencing Behavior

Source: https://states-language.net/

Illustrates how variable assignments work. The 'Assign' field evaluates expressions using the variable's value at the time the state is entered. The new value of a variable only takes effect in the subsequent state.

```json
{
  "Assigning": {
    "Type": "Pass",
    "QueryLanguage": "JSONata",
    "Assign": {
      "x": 42,
      "newOrOld": "{% $x %}"
    },
    "Next": "Referencing"
  }

}
```

--------------------------------

### Fail State with Error and Cause

Source: https://states-language.net/

Terminates a state machine and marks it as a failure. Optionally includes an 'Error' name and a human-readable 'Cause' message.

```json
"FailState": {
  "Type": "Fail",
  "Error": "ErrorA",
  "Cause": "Kaiju attack"
}
```

--------------------------------

### Partition Array into Chunks

Source: https://states-language.net/

Use States.ArrayPartition to divide a large array into smaller, manageable chunks. Specify the desired chunk size as the second argument. The last chunk may be smaller if remaining elements are fewer than the chunk size.

```json
{ "inputArray": [1,2,3,4,5,6,7,8,9] }
```

```json
{ "inputArray.$": "States.ArrayPartition($.inputArray,4)" }
```

```json
{ "inputArray": [ [1,2,3,4], [5,6,7,8], [9]] }
```

--------------------------------

### Advanced Payload Template with Paths and Intrinsic Functions

Source: https://states-language.net/

This Task State uses a Payload Template with fields ending in '.$' to dynamically insert data. Paths are used to select data from the input payload ('$') or the context object ('$$'), and Intrinsic Functions like States.Format can transform data.

```json
"X": {
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:task:X",
  "Next": "Y",
  "Parameters": {
    "flagged": true,
    "parts": {
      "first.$": "$.vals[0]",
      "last3.$": "$.vals[-3:]"
    },
    "weekday.$": "$$.DayOfWeek",
    "formattedOutput.$": "States.Format('Today is {}', $$.DayOfWeek)"
  }
}

```

--------------------------------

### Add Numbers with States.MathAdd

Source: https://states-language.net/

Use States.MathAdd to sum two integers. This is useful for incrementing values within loops. All arguments must be integers.

```json
{ "value1": 111, "step": -1 }
```

```json
{ "value1.$": "States.MathAdd($.value1, $.step)" }
```

```json
{ "value1": 110 }
```

--------------------------------

### Retry Policy with Max Delay

Source: https://states-language.net/

Configures a retry policy with a maximum delay of 4 seconds between attempts.

```json
"Retry" : [
  {
    "ErrorEquals": [ "States.Timeout" ],
    "IntervalSeconds": 3,
    "MaxAttempts": 2,
    "BackoffRate": 2.0,
    "MaxDelaySeconds": 4
  }
]
```

--------------------------------

### JSONPath Map State Configuration

Source: https://states-language.net/

Utilizes JSONPath for selecting items and processing them with a Lambda function. 'InputPath' and 'ItemsPath' define the data sources, and 'ResultPath' updates the output.

```json
"Validate-All": {
  "Type": "Map",
  "InputPath": "$.detail",
  "ItemsPath": "$.shipped",
  "MaxConcurrency": 0,
  "ItemProcessor": {
    "StartAt": "Validate",
    "States": {
      "Validate": {
        "Type": "Task",
        "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ship-val",
        "End": true
      }
    }
  },
  "ResultPath": "$.detail.shipped",
  "End": true
}

```

--------------------------------

### Basic Retry Policy

Source: https://states-language.net/

Defines a retry policy for 'States.Timeout' errors with 2 attempts and increasing intervals.

```json
"Retry" : [
  {
    "ErrorEquals": [ "States.Timeout" ],
    "IntervalSeconds": 3,
    "MaxAttempts": 2,
    "BackoffRate": 2.0
  }
]
```

--------------------------------

### Override Query Language for Specific States

Source: https://states-language.net/

Demonstrates overriding the default query language at both the state machine and individual state levels. The 'JSONPath state' uses the machine's default, while the 'JSONata state' uses its own specified language.

```json
{
  "QueryLanguage": "JSONPath",
  "StartAt": "JSONPath state",
  "States": {
    "JSONPath state": {
      "Type": "Pass",
      "Parameters": {
        "total.$": "$.transaction.total"
      },
      "Next": "JSONata state"
    },
    "JSONata state": {
      "Type": "Pass",
      "QueryLanguage": "JSONata",
      "Output": {
        "total": "{% $states.input.transaction.total %}"
      },
      "End": true
    }
  }
}
```

--------------------------------

### Using States.JsonToString Intrinsic Function

Source: https://states-language.net/

Shows how to convert a JSON object or value identified by a Path into its string representation using States.JsonToString. The argument must be a Path to a JSON value.

```json
{
  "Parameters": {
    "foo.$": "States.JsonToString($.someJson)"
  }
}
```

--------------------------------

### Accessing State Variables with JSONata

Source: https://states-language.net/

Shows how to reference state input, result, error output, and context object using the reserved 'states' variable in JSONata expressions. This is useful for shaping the output or handling errors based on execution state.

```JSONata
{% $states.input.customer %}
```

```JSONata
{% $states.result.status %}
```

```JSONata
{% $states.context.ElapsedTime %}
```

```JSONata
{% $states.errorOutput %}
```

--------------------------------

### Resulting Effective Input to Task Resource

Source: https://states-language.net/

The final JSON object after the Payload Template has been processed, combining static values, data from the input payload, context object, and intrinsic function results.

```json
{
  "flagged": true,
  "parts": {
    "first": 0,
    "last3": [30, 40, 50]
  },
  "weekday": "TUESDAY",
  "formattedOutput": "Today is TUESDAY"
}

```

--------------------------------

### Generate Array with Range and Increment

Source: https://states-language.net/

Use States.ArrayRange to create a new array with elements within a specified range and increment. The maximum array size is 1000 elements. All arguments must be integers, and the increment cannot be zero.

```json
{ "array.$": "States.ArrayRange(1, 9, 2)" }
```

```json
{ "array": [1,3,5,7,9] }
```

--------------------------------

### Define and Use Custom JSONata Function

Source: https://states-language.net/

Demonstrates defining a custom function for calculations within a JSONata expression. Use this for complex data manipulations not covered by built-in functions.

```JSONata
{% ($product := function($x, $y) {$x * $y}; $reduce([1..5], $product)) %}
```

--------------------------------

### Generate Random Number with States.MathRandom

Source: https://states-language.net/

Use States.MathRandom to generate a random number within a specified range. The seed value is optional and ensures reproducible results if provided. Not recommended for security-sensitive applications.

```json
{ "start": 1, "end": 999 }
```

```json
{ "random.$": "States.MathRandom($.start, $.end)" }
```

```json
{ "random": 456 }
```

--------------------------------

### Modify State Definition with InputPath and ResultPath

Source: https://states-language.net/

These fields are added to the state definition to specify how input and results should be processed.

```json
"InputPath": "$.numbers",
"ResultPath": "$.sum"
```

--------------------------------

### Wait State with Timestamp

Source: https://states-language.net/

Delays execution until a specific absolute time. The timestamp must conform to RFC3339 with specific formatting (uppercase 'T' and 'Z').

```json
"wait_until" : {
  "Type": "Wait",
  "Timestamp": "2016-03-14T01:59:00Z",
  "Next": "NextState"
}
```

--------------------------------

### Calculate Hash Value

Source: https://states-language.net/

Use States.Hash to compute a hash value for input data using a specified algorithm (e.g., MD5, SHA-256). The data to hash must have a stringified length of 10,000 characters or less.

```json
{ "Data": "input data", "Algorithm": "SHA-1" }
```

```json
{ "output.$": "States.Hash($.Data, $.Algorithm)" }
```

```json
{ "output": "aaff4a450a104cd177d28d18d7485e8cae074b7" }
```

--------------------------------

### Variable Scope in Nested States (Map State)

Source: https://states-language.net/

Demonstrates variable scope within a state machine, including inner scopes created by Map states. Variables assigned in an outer scope can be referenced by inner scopes, but inner scopes cannot assign to variables with the same name as outer-scoped variables.

```json
{
  "QueryLanguage": "JSONata",
  "StartAt": "Get Greeting",
  "States": {
    "Get Greeting": {
      "Type": "Pass",
      "Assign": {
        "outer": "hello"
      },
      "Next": "Greet Everyone"
    },
    "Greet Everyone": {
      "Type": "Map",
      "ItemProcessor": {
        "StartAt": "Begin",
        "States": {
          "Begin": {
            "Type": "Pass",
            "Assign": {
              "inner": "world",
              "hi": "{% $outer %}"
            },
            "Next": "End"
          },
          "End": {
            "Type": "Succeed",
            "Output": "{% $hi %}"
          }
        }
      },
      "Assign": {
        "outer": 2
      },
      "Next": "Goodbye"
    },
    "Goodbye": {
      "Type": "Succeed",
      "Output": "{% $outer %}"
    }
  }
}
```

--------------------------------

### ResultPath Overwriting Field

Source: https://states-language.net/

Demonstrates how ResultPath overwrites an existing field in the raw input when placing the state's result.

```json
{
  "master": {
    "detail": [1, 2, 3]
  }
}
```

```json
{
  "master": {
    "detail": 6
  }
}
```

--------------------------------

### JSONPath Wait State with TimestampPath

Source: https://states-language.net/

Uses a JSONPath expression to dynamically select the timestamp from the state's input. The selected value must be a valid timestamp string.

```json
"wait_until" : {
  "Type": "Wait",
  "TimestampPath": "$.expirydate",
  "Next": "NextState"
}
```

--------------------------------

### JSONPath Fail State with Dynamic ErrorPath and CausePath

Source: https://states-language.net/

Dynamically sets the 'Error' and 'Cause' fields for a Fail state using JSONPath expressions to select values from the state input.

```json
"FailState": {
  "Type": "Fail",
  "Comment": "my error comment",
  "ErrorPath": "$.Error",
  "CausePath": "$.Cause"
}
```

--------------------------------

### Assigning Variables in a Pass State

Source: https://states-language.net/

Use the 'Assign' field in a Pass state to set variable values. These variables can be referenced in subsequent states. The 'Assign' field must be a JSON object where keys are variable names and values are their new assignments.

```json
{
  "FirstState": {
    "Type": "Pass",
    "Assign": {
      "make": "Infiniti",
      "model": "G35",
      "year": 2006
    },
    "Next": "SecondState"
  }

}
```
Tokens:
Raw