# TaskInput

Type union for task classes that accept multiple types of payload.

Obtainable from: TaskInput.fromJsonPathAt, TaskInput.fromObject, TaskInput.fromText

- Source: [`aws-stepfunctions/lib/input.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/aws-stepfunctions/lib/input.ts#L6)

## Example

TypeScript:

```ts
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
declare const api: apigateway.RestApi;

tasks.CallApiGatewayRestApiEndpoint.jsonata(this, 'Endpoint', {
  api,
  stageName: 'Stage',
  method: tasks.HttpMethod.PUT,
  integrationPattern: sfn.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
  headers: sfn.TaskInput.fromObject({
    TaskToken: '{% States.Array($states.context.taskToken) %}',
  }),
});
```

Python:

```python
import aws_cdk.aws_apigateway as apigateway
# api: apigateway.RestApi

tasks.CallApiGatewayRestApiEndpoint.jsonata(self, "Endpoint",
    api=api,
    stage_name="Stage",
    method=tasks.HttpMethod.PUT,
    integration_pattern=sfn.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
    headers=sfn.TaskInput.from_object({
        "TaskToken": "{% States.Array($states.context.taskToken) %}"
    })
)
```

Java:

```java
import software.amazon.awscdk.services.apigateway.*;
RestApi api;

CallApiGatewayRestApiEndpoint.jsonata(this, "Endpoint", CallApiGatewayRestApiEndpointJsonataProps.builder()
        .api(api)
        .stageName("Stage")
        .method(HttpMethod.PUT)
        .integrationPattern(IntegrationPattern.WAIT_FOR_TASK_TOKEN)
        .headers(TaskInput.fromObject(Map.of(
                "TaskToken", "{% States.Array($states.context.taskToken) %}")))
        .build());
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.APIGateway;
RestApi api;

CallApiGatewayRestApiEndpoint.Jsonata(this, "Endpoint", new CallApiGatewayRestApiEndpointJsonataProps {
    Api = api,
    StageName = "Stage",
    Method = HttpMethod.PUT,
    IntegrationPattern = IntegrationPattern.WAIT_FOR_TASK_TOKEN,
    Headers = TaskInput.FromObject(new Dictionary<string, object> {
        { "TaskToken", "{% States.Array($states.context.taskToken) %}" }
    })
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import apigateway "github.com/aws/aws-cdk-go/awscdk"
var api RestApi

tasks.CallApiGatewayRestApiEndpoint_Jsonata(this, jsii.String("Endpoint"), &CallApiGatewayRestApiEndpointJsonataProps{
	Api: Api,
	StageName: jsii.String("Stage"),
	Method: tasks.HttpMethod_PUT,
	IntegrationPattern: sfn.IntegrationPattern_WAIT_FOR_TASK_TOKEN,
	Headers: sfn.TaskInput_FromObject(map[string]interface{}{
		"TaskToken": jsii.String("{% States.Array($states.context.taskToken) %}"),
	}),
})
```

## Properties

- `type`: [InputType](/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions.InputType.html) — type of task input.

- `value`: any — payload for the corresponding input type.

  It can be a JSON-encoded object, context, data, etc.

## Methods

- `fromJsonPathAt(path: string): TaskInput // chainable` (static) — Use a part of the execution data or task context as task input.

  Use this when you want to use a subobject or string from
  the current state machine execution or the current task context
  as complete payload to a task.

- `fromObject(obj: { [key: string]: any }): TaskInput // chainable` (static) — Use an object as task input.

  This object may contain JSON path fields as object values, if desired.

  Use `sfn.JsonPath.DISCARD` in place of `null` for languages that do not support `null` (i.e. Python).

- `fromText(text: string): TaskInput // chainable` (static) — Use a literal string as task input.

  This might be a JSON-encoded object, or just a text.
