# MapBaseOptions

Base properties for defining a Map state.

Extends: [AssignableStateOptions](/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.AssignableStateOptions.html)

- Source: [`aws-stepfunctions/lib/states/map-base.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/aws-stepfunctions/lib/states/map-base.ts#L96)
- Type last changed: v2.235.0 · 15 Jan 2026

## Example

TypeScript:

```ts
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';

declare const assign: any;
declare const itemSelector: any;
const mapBaseOptions: stepfunctions.MapBaseOptions = {
  assign: {
    assignKey: assign,
  },
  itemSelector: {
    itemSelectorKey: itemSelector,
  },
  jsonataItemSelector: 'jsonataItemSelector',
  jsonataMaxConcurrency: 'jsonataMaxConcurrency',
  maxConcurrency: 123,
};
```

Python:

```python
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
from aws_cdk import aws_stepfunctions as stepfunctions

# assign: Any
# item_selector: Any

map_base_options = stepfunctions.MapBaseOptions(
    assign={
        "assign_key": assign
    },
    item_selector={
        "item_selector_key": item_selector
    },
    jsonata_item_selector="jsonataItemSelector",
    jsonata_max_concurrency="jsonataMaxConcurrency",
    max_concurrency=123
)
```

Java:

```java
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.stepfunctions.*;

Object assign;
Object itemSelector;

MapBaseOptions mapBaseOptions = MapBaseOptions.builder()
        .assign(Map.of(
                "assignKey", assign))
        .itemSelector(Map.of(
                "itemSelectorKey", itemSelector))
        .jsonataItemSelector("jsonataItemSelector")
        .jsonataMaxConcurrency("jsonataMaxConcurrency")
        .maxConcurrency(123)
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.StepFunctions;

var assign;
var itemSelector;

var mapBaseOptions = new MapBaseOptions {
    Assign = new Dictionary<string, object> {
        { "assignKey", assign }
    },
    ItemSelector = new Dictionary<string, object> {
        { "itemSelectorKey", itemSelector }
    },
    JsonataItemSelector = "jsonataItemSelector",
    JsonataMaxConcurrency = "jsonataMaxConcurrency",
    MaxConcurrency = 123
};
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var assign interface{}
var itemSelector interface{}

mapBaseOptions := &MapBaseOptions{
	Assign: map[string]interface{}{
		"assignKey": assign,
	},
	ItemSelector: map[string]interface{}{
		"itemSelectorKey": itemSelector,
	},
	JsonataItemSelector: jsii.String("jsonataItemSelector"),
	JsonataMaxConcurrency: jsii.String("jsonataMaxConcurrency"),
	MaxConcurrency: jsii.Number(123),
}
```

## Properties

- `assign`: { [key: string]: any } — Workflow variables to store in this step.

  **Default:** Not assign variables

  Using workflow variables, you can store data in a step and retrieve that data in future steps.

- `itemSelector`: { [key: string]: any } = $ — The JSON that you want to override your default iteration input (mutually exclusive with `parameters` and `jsonataItemSelector`).

- `jsonataItemSelector`: string = $ — 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} %}`

- `jsonataMaxConcurrency`: string — JSONata expression for MaxConcurrency.

  **Default:** full concurrency

  A JSONata expression that evaluates to an integer, specifying the maximum
  concurrency dynamically. Mutually exclusive with `maxConcurrency` and
  `maxConcurrencyPath`.

  Example value: `{% $states.input.maxConcurrency %}`

- `maxConcurrency`: number — MaxConcurrency.

  **Default:** full concurrency

  An upper bound on the number of iterations you want running at once.
