> **Experimental**
>
> `@aws-cdk/integ-tests-alpha` is an [**experimental**](/stability) (alpha) package: its API may change in any release, without a major version bump.
# WaiterStateMachineOptions

Options for creating a WaiterStateMachine.

Extends: [ProviderOptions](/cdk/api/v2/docs/@aws-cdk_integ-tests-alpha.ProviderOptions.html)

- Stability: [Experimental](/cdk/api/stability.html)
- Source: [`lib/assertions/waiter-state-machine.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/@aws-cdk/integ-tests-alpha/lib/assertions/waiter-state-machine.ts#L10)

## Example

TypeScript:

```ts
#!/usr/bin/env node
import * as path from 'path';
import * as firehose from 'aws-cdk-lib/aws-kinesisfirehose';
import * as kms from 'aws-cdk-lib/aws-kms';
import * as lambdanodejs from 'aws-cdk-lib/aws-lambda-nodejs';
import * as logs from 'aws-cdk-lib/aws-logs';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as cdk from 'aws-cdk-lib';
import { AwsApiCall, ExpectedResult, IntegTest } from '@aws-cdk/integ-tests-alpha';

const app = new cdk.App({
  postCliContext: {
    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
  },
});

const stack = new cdk.Stack(app, 'aws-cdk-firehose-delivery-stream-s3-all-properties');

const bucket = new s3.Bucket(stack, 'FirehoseDeliveryStreamS3AllPropertiesBucket', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
  autoDeleteObjects: true,
});

const backupBucket = new s3.Bucket(stack, 'FirehoseDeliveryStreamS3AllPropertiesBackupBucket', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
  autoDeleteObjects: true,
});
const logGroup = new logs.LogGroup(stack, 'LogGroup', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const dataProcessorFunction = new lambdanodejs.NodejsFunction(stack, 'DataProcessorFunction', {
  entry: path.join(__dirname, 'lambda-data-processor.js'),
  timeout: cdk.Duration.minutes(1),
});

const processor = new firehose.LambdaFunctionProcessor(dataProcessorFunction, {
  bufferInterval: cdk.Duration.seconds(60),
  bufferSize: cdk.Size.mebibytes(1),
  retries: 1,
});

const key = new kms.Key(stack, 'Key', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const backupKey = new kms.Key(stack, 'BackupKey', {
  removalPolicy: cdk.RemovalPolicy.DESTROY,
});

const deliveryStream = new firehose.DeliveryStream(stack, 'DeliveryStream', {
  destination: new firehose.S3Bucket(bucket, {
    loggingConfig: new firehose.EnableLogging(logGroup),
    processors: [processor],
    compression: firehose.Compression.GZIP,
    dataOutputPrefix: 'regularPrefix',
    errorOutputPrefix: 'errorPrefix',
    fileExtension: '.log.gz',
    timeZone: cdk.TimeZone.ASIA_TOKYO,
    bufferingInterval: cdk.Duration.seconds(60),
    bufferingSize: cdk.Size.mebibytes(1),
    encryptionKey: key,
    s3Backup: {
      mode: firehose.BackupMode.ALL,
      bucket: backupBucket,
      compression: firehose.Compression.ZIP,
      dataOutputPrefix: 'backupPrefix',
      errorOutputPrefix: 'backupErrorPrefix',
      bufferingInterval: cdk.Duration.seconds(60),
      bufferingSize: cdk.Size.mebibytes(1),
      encryptionKey: backupKey,
    },
  }),
});

new firehose.DeliveryStream(stack, 'ZeroBufferingDeliveryStream', {
  destination: new firehose.S3Bucket(bucket, {
    compression: firehose.Compression.GZIP,
    dataOutputPrefix: 'regularPrefix',
    errorOutputPrefix: 'errorPrefix',
    bufferingInterval: cdk.Duration.seconds(0),
  }),
});

const testCase = new IntegTest(app, 'integ-tests', {
  testCases: [stack],
  regions: ['us-east-1'],
});

testCase.assertions.awsApiCall('Firehose', 'putRecord', {
  DeliveryStreamName: deliveryStream.deliveryStreamName,
  Record: {
    Data: 'testData123',
  },
});

const s3ApiCall = testCase.assertions.awsApiCall('S3', 'listObjectsV2', {
  Bucket: bucket.bucketName,
  MaxKeys: 1,
}).expect(ExpectedResult.objectLike({
  KeyCount: 1,
})).waitForAssertions({
  interval: cdk.Duration.seconds(30),
  totalTimeout: cdk.Duration.minutes(10),
});

if (s3ApiCall instanceof AwsApiCall && s3ApiCall.waiterProvider) {
  s3ApiCall.waiterProvider.addToRolePolicy({
    Effect: 'Allow',
    Action: ['s3:GetObject', 's3:ListBucket'],
    Resource: ['*'],
  });
}
```

Python:

```python
import path as path
import aws_cdk.aws_kinesisfirehose as firehose
import aws_cdk.aws_kms as kms
import aws_cdk.aws_lambda_nodejs as lambdanodejs
import aws_cdk.aws_logs as logs
import aws_cdk.aws_s3 as s3
import aws_cdk as cdk
from aws_cdk.integ_tests_alpha import AwsApiCall, ExpectedResult, IntegTest

app = cdk.App(
    post_cli_context={
        "@aws-cdk/aws-lambda:useCdkManagedLogGroup": False
    }
)

stack = cdk.Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties")

bucket = s3.Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket",
    removal_policy=cdk.RemovalPolicy.DESTROY,
    auto_delete_objects=True
)

backup_bucket = s3.Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket",
    removal_policy=cdk.RemovalPolicy.DESTROY,
    auto_delete_objects=True
)
log_group = logs.LogGroup(stack, "LogGroup",
    removal_policy=cdk.RemovalPolicy.DESTROY
)

data_processor_function = lambdanodejs.NodejsFunction(stack, "DataProcessorFunction",
    entry=path.join(__dirname, "lambda-data-processor.js"),
    timeout=cdk.Duration.minutes(1)
)

processor = firehose.LambdaFunctionProcessor(data_processor_function,
    buffer_interval=cdk.Duration.seconds(60),
    buffer_size=cdk.Size.mebibytes(1),
    retries=1
)

key = kms.Key(stack, "Key",
    removal_policy=cdk.RemovalPolicy.DESTROY
)

backup_key = kms.Key(stack, "BackupKey",
    removal_policy=cdk.RemovalPolicy.DESTROY
)

delivery_stream = firehose.DeliveryStream(stack, "DeliveryStream",
    destination=firehose.S3Bucket(bucket,
        logging_config=firehose.EnableLogging(log_group),
        processors=[processor],
        compression=firehose.Compression.GZIP,
        data_output_prefix="regularPrefix",
        error_output_prefix="errorPrefix",
        file_extension=".log.gz",
        time_zone=cdk.TimeZone.ASIA_TOKYO,
        buffering_interval=cdk.Duration.seconds(60),
        buffering_size=cdk.Size.mebibytes(1),
        encryption_key=key,
        s3_backup=firehose.DestinationS3BackupProps(
            mode=firehose.BackupMode.ALL,
            bucket=backup_bucket,
            compression=firehose.Compression.ZIP,
            data_output_prefix="backupPrefix",
            error_output_prefix="backupErrorPrefix",
            buffering_interval=cdk.Duration.seconds(60),
            buffering_size=cdk.Size.mebibytes(1),
            encryption_key=backup_key
        )
    )
)

firehose.DeliveryStream(stack, "ZeroBufferingDeliveryStream",
    destination=firehose.S3Bucket(bucket,
        compression=firehose.Compression.GZIP,
        data_output_prefix="regularPrefix",
        error_output_prefix="errorPrefix",
        buffering_interval=cdk.Duration.seconds(0)
    )
)

test_case = IntegTest(app, "integ-tests",
    test_cases=[stack],
    regions=["us-east-1"]
)

test_case.assertions.aws_api_call("Firehose", "putRecord", {
    "DeliveryStreamName": delivery_stream.delivery_stream_name,
    "Record": {
        "Data": "testData123"
    }
})

s3_api_call = test_case.assertions.aws_api_call("S3", "listObjectsV2", {
    "Bucket": bucket.bucket_name,
    "MaxKeys": 1
}).expect(ExpectedResult.object_like({
    "KeyCount": 1
})).wait_for_assertions(
    interval=cdk.Duration.seconds(30),
    total_timeout=cdk.Duration.minutes(10)
)

if s3_api_call instanceof AwsApiCall && s3_api_call.waiter_provider:
    s3_api_call.waiter_provider.add_to_role_policy({
        "Effect": "Allow",
        "Action": ["s3:GetObject", "s3:ListBucket"],
        "Resource": ["*"]
    })
```

Java:

```java
import path.*;
import software.amazon.awscdk.services.kinesisfirehose.*;
import software.amazon.awscdk.services.kms.*;
import software.amazon.awscdk.services.lambda.nodejs.*;
import software.amazon.awscdk.services.logs.*;
import software.amazon.awscdk.services.s3.*;
import software.amazon.awscdk.*;
import software.amazon.awscdk.integtests.alpha.AwsApiCall;
import software.amazon.awscdk.integtests.alpha.ExpectedResult;
import software.amazon.awscdk.integtests.alpha.IntegTest;

App app = App.Builder.create()
        .postCliContext(Map.of(
                "@aws-cdk/aws-lambda:useCdkManagedLogGroup", false))
        .build();

Stack stack = new Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties");

Bucket bucket = Bucket.Builder.create(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket")
        .removalPolicy(RemovalPolicy.DESTROY)
        .autoDeleteObjects(true)
        .build();

Bucket backupBucket = Bucket.Builder.create(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket")
        .removalPolicy(RemovalPolicy.DESTROY)
        .autoDeleteObjects(true)
        .build();
LogGroup logGroup = LogGroup.Builder.create(stack, "LogGroup")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();

NodejsFunction dataProcessorFunction = NodejsFunction.Builder.create(stack, "DataProcessorFunction")
        .entry(join(__dirname, "lambda-data-processor.js"))
        .timeout(Duration.minutes(1))
        .build();

LambdaFunctionProcessor processor = LambdaFunctionProcessor.Builder.create(dataProcessorFunction)
        .bufferInterval(Duration.seconds(60))
        .bufferSize(Size.mebibytes(1))
        .retries(1)
        .build();

Key key = Key.Builder.create(stack, "Key")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();

Key backupKey = Key.Builder.create(stack, "BackupKey")
        .removalPolicy(RemovalPolicy.DESTROY)
        .build();

DeliveryStream deliveryStream = DeliveryStream.Builder.create(stack, "DeliveryStream")
        .destination(S3Bucket.Builder.create(bucket)
                .loggingConfig(new EnableLogging(logGroup))
                .processors(List.of(processor))
                .compression(Compression.GZIP)
                .dataOutputPrefix("regularPrefix")
                .errorOutputPrefix("errorPrefix")
                .fileExtension(".log.gz")
                .timeZone(TimeZone.ASIA_TOKYO)
                .bufferingInterval(Duration.seconds(60))
                .bufferingSize(Size.mebibytes(1))
                .encryptionKey(key)
                .s3Backup(DestinationS3BackupProps.builder()
                        .mode(BackupMode.ALL)
                        .bucket(backupBucket)
                        .compression(Compression.ZIP)
                        .dataOutputPrefix("backupPrefix")
                        .errorOutputPrefix("backupErrorPrefix")
                        .bufferingInterval(Duration.seconds(60))
                        .bufferingSize(Size.mebibytes(1))
                        .encryptionKey(backupKey)
                        .build())
                .build())
        .build();

DeliveryStream.Builder.create(stack, "ZeroBufferingDeliveryStream")
        .destination(S3Bucket.Builder.create(bucket)
                .compression(Compression.GZIP)
                .dataOutputPrefix("regularPrefix")
                .errorOutputPrefix("errorPrefix")
                .bufferingInterval(Duration.seconds(0))
                .build())
        .build();

IntegTest testCase = IntegTest.Builder.create(app, "integ-tests")
        .testCases(List.of(stack))
        .regions(List.of("us-east-1"))
        .build();

testCase.assertions.awsApiCall("Firehose", "putRecord", Map.of(
        "DeliveryStreamName", deliveryStream.getDeliveryStreamName(),
        "Record", Map.of(
                "Data", "testData123")));

IApiCall s3ApiCall = testCase.assertions.awsApiCall("S3", "listObjectsV2", Map.of(
        "Bucket", bucket.bucketName,
        "MaxKeys", 1)).expect(ExpectedResult.objectLike(Map.of(
        "KeyCount", 1))).waitForAssertions(WaiterStateMachineOptions.builder()
        .interval(Duration.seconds(30))
        .totalTimeout(Duration.minutes(10))
        .build());

if (s3ApiCall instanceof AwsApiCall && s3ApiCall.getWaiterProvider()) {
    s3ApiCall.waiterProvider.addToRolePolicy(Map.of(
            "Effect", "Allow",
            "Action", List.of("s3:GetObject", "s3:ListBucket"),
            "Resource", List.of("*")));
}
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.IntegTests.Alpha
using Path;
using Amazon.CDK.AWS.KinesisFirehose;
using Amazon.CDK.AWS.KMS;
using Amazon.CDK.AWS.Lambda.Nodejs;
using Amazon.CDK.AWS.Logs;
using Amazon.CDK.AWS.S3;
using Amazon.CDK;
using Amazon.CDK.IntegTests.Alpha;

var app = new App(new AppProps {
    PostCliContext = new Dictionary<string, object> {
        { "@aws-cdk/aws-lambda:useCdkManagedLogGroup", false }
    }
});

var stack = new Stack(app, "aws-cdk-firehose-delivery-stream-s3-all-properties");

var bucket = new Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBucket", new BucketProps {
    RemovalPolicy = RemovalPolicy.DESTROY,
    AutoDeleteObjects = true
});

var backupBucket = new Bucket(stack, "FirehoseDeliveryStreamS3AllPropertiesBackupBucket", new BucketProps {
    RemovalPolicy = RemovalPolicy.DESTROY,
    AutoDeleteObjects = true
});
var logGroup = new LogGroup(stack, "LogGroup", new LogGroupProps {
    RemovalPolicy = RemovalPolicy.DESTROY
});

var dataProcessorFunction = new NodejsFunction(stack, "DataProcessorFunction", new NodejsFunctionProps {
    Entry = Join(__dirname, "lambda-data-processor.js"),
    Timeout = Duration.Minutes(1)
});

var processor = new LambdaFunctionProcessor(dataProcessorFunction, new DataProcessorProps {
    BufferInterval = Duration.Seconds(60),
    BufferSize = Size.Mebibytes(1),
    Retries = 1
});

var key = new Key(stack, "Key", new KeyProps {
    RemovalPolicy = RemovalPolicy.DESTROY
});

var backupKey = new Key(stack, "BackupKey", new KeyProps {
    RemovalPolicy = RemovalPolicy.DESTROY
});

var deliveryStream = new DeliveryStream(stack, "DeliveryStream", new DeliveryStreamProps {
    Destination = new S3Bucket(bucket, new S3BucketProps {
        LoggingConfig = new EnableLogging(logGroup),
        Processors = new [] { processor },
        Compression = Compression.GZIP,
        DataOutputPrefix = "regularPrefix",
        ErrorOutputPrefix = "errorPrefix",
        FileExtension = ".log.gz",
        TimeZone = TimeZone.ASIA_TOKYO,
        BufferingInterval = Duration.Seconds(60),
        BufferingSize = Size.Mebibytes(1),
        EncryptionKey = key,
        S3Backup = new DestinationS3BackupProps {
            Mode = BackupMode.ALL,
            Bucket = backupBucket,
            Compression = Compression.ZIP,
            DataOutputPrefix = "backupPrefix",
            ErrorOutputPrefix = "backupErrorPrefix",
            BufferingInterval = Duration.Seconds(60),
            BufferingSize = Size.Mebibytes(1),
            EncryptionKey = backupKey
        }
    })
});

new DeliveryStream(stack, "ZeroBufferingDeliveryStream", new DeliveryStreamProps {
    Destination = new S3Bucket(bucket, new S3BucketProps {
        Compression = Compression.GZIP,
        DataOutputPrefix = "regularPrefix",
        ErrorOutputPrefix = "errorPrefix",
        BufferingInterval = Duration.Seconds(0)
    })
});

var testCase = new IntegTest(app, "integ-tests", new IntegTestProps {
    TestCases = new [] { stack },
    Regions = new [] { "us-east-1" }
});

testCase.Assertions.AwsApiCall("Firehose", "putRecord", new Dictionary<string, object> {
    { "DeliveryStreamName", deliveryStream.DeliveryStreamName },
    { "Record", new Struct {
        Data = "testData123"
    } }
});

var s3ApiCall = testCase.Assertions.AwsApiCall("S3", "listObjectsV2", new Dictionary<string, object> {
    { "Bucket", bucket.BucketName },
    { "MaxKeys", 1 }
}).Expect(ExpectedResult.ObjectLike(new Dictionary<string, object> {
    { "KeyCount", 1 }
})).WaitForAssertions(new WaiterStateMachineOptions {
    Interval = Duration.Seconds(30),
    TotalTimeout = Duration.Minutes(10)
});

if (s3ApiCall instanceof AwsApiCall && s3ApiCall.WaiterProvider)
{
    s3ApiCall.WaiterProvider.AddToRolePolicy(new Dictionary<string, object> {
        { "Effect", "Allow" },
        { "Action", new [] { "s3:GetObject", "s3:ListBucket" } },
        { "Resource", new [] { "*" } }
    });
}
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdkintegtestsalpha/v2
import path "github.com/aws-samples/dummy/path"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import lambdanodejs "github.com/aws/aws-cdk-go/awscdk"
import logs "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdkintegtestsalpha"

app := cdk.NewApp(&AppProps{
	PostCliContext: map[string]interface{}{
		"@aws-cdk/aws-lambda:useCdkManagedLogGroup": jsii.Boolean(false),
	},
})

stack := cdk.NewStack(app, jsii.String("aws-cdk-firehose-delivery-stream-s3-all-properties"))

bucket := s3.NewBucket(stack, jsii.String("FirehoseDeliveryStreamS3AllPropertiesBucket"), &BucketProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
	AutoDeleteObjects: jsii.Boolean(true),
})

backupBucket := s3.NewBucket(stack, jsii.String("FirehoseDeliveryStreamS3AllPropertiesBackupBucket"), &BucketProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
	AutoDeleteObjects: jsii.Boolean(true),
})
logGroup := logs.NewLogGroup(stack, jsii.String("LogGroup"), &LogGroupProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
})

dataProcessorFunction := lambdanodejs.NewNodejsFunction(stack, jsii.String("DataProcessorFunction"), &NodejsFunctionProps{
	Entry: path.join(__dirname, jsii.String("lambda-data-processor.js")),
	Timeout: cdk.Duration_Minutes(jsii.Number(1)),
})

processor := firehose.NewLambdaFunctionProcessor(dataProcessorFunction, &DataProcessorProps{
	BufferInterval: cdk.Duration_Seconds(jsii.Number(60)),
	BufferSize: cdk.Size_Mebibytes(jsii.Number(1)),
	Retries: jsii.Number(1),
})

key := kms.NewKey(stack, jsii.String("Key"), &KeyProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
})

backupKey := kms.NewKey(stack, jsii.String("BackupKey"), &KeyProps{
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
})

deliveryStream := firehose.NewDeliveryStream(stack, jsii.String("DeliveryStream"), &DeliveryStreamProps{
	Destination: firehose.NewS3Bucket(bucket, &S3BucketProps{
		LoggingConfig: firehose.NewEnableLogging(logGroup),
		Processors: []IDataProcessor{
			processor,
		},
		Compression: firehose.Compression_GZIP(),
		DataOutputPrefix: jsii.String("regularPrefix"),
		ErrorOutputPrefix: jsii.String("errorPrefix"),
		FileExtension: jsii.String(".log.gz"),
		TimeZone: cdk.TimeZone_ASIA_TOKYO(),
		BufferingInterval: cdk.Duration_*Seconds(jsii.Number(60)),
		BufferingSize: cdk.Size_*Mebibytes(jsii.Number(1)),
		EncryptionKey: key,
		S3Backup: &DestinationS3BackupProps{
			Mode: firehose.BackupMode_ALL,
			Bucket: backupBucket,
			Compression: firehose.Compression_ZIP(),
			DataOutputPrefix: jsii.String("backupPrefix"),
			ErrorOutputPrefix: jsii.String("backupErrorPrefix"),
			BufferingInterval: cdk.Duration_*Seconds(jsii.Number(60)),
			BufferingSize: cdk.Size_*Mebibytes(jsii.Number(1)),
			EncryptionKey: backupKey,
		},
	}),
})

firehose.NewDeliveryStream(stack, jsii.String("ZeroBufferingDeliveryStream"), &DeliveryStreamProps{
	Destination: firehose.NewS3Bucket(bucket, &S3BucketProps{
		Compression: firehose.Compression_GZIP(),
		DataOutputPrefix: jsii.String("regularPrefix"),
		ErrorOutputPrefix: jsii.String("errorPrefix"),
		BufferingInterval: cdk.Duration_*Seconds(jsii.Number(0)),
	}),
})

testCase := awscdkintegtestsalpha.NewIntegTest(app, jsii.String("integ-tests"), &IntegTestProps{
	TestCases: []Stack{
		stack,
	},
	Regions: []*string{
		jsii.String("us-east-1"),
	},
})

testCase.Assertions.AwsApiCall(jsii.String("Firehose"), jsii.String("putRecord"), map[string]interface{}{
	"DeliveryStreamName": deliveryStream.deliveryStreamName,
	"Record": map[string]*string{
		"Data": jsii.String("testData123"),
	},
})

s3ApiCall := testCase.Assertions.AwsApiCall(jsii.String("S3"), jsii.String("listObjectsV2"), map[string]interface{}{
	"Bucket": bucket.bucketName,
	"MaxKeys": jsii.Number(1),
}).Expect(awscdkintegtestsalpha.ExpectedResult_ObjectLike(map[string]interface{}{
	"KeyCount": jsii.Number(1),
})).WaitForAssertions(&WaiterStateMachineOptions{
	Interval: cdk.Duration_*Seconds(jsii.Number(30)),
	TotalTimeout: cdk.Duration_*Minutes(jsii.Number(10)),
})

if s3ApiCall instanceof awscdkintegtestsalpha.AwsApiCall && s3ApiCall.WaiterProvider {
	s3ApiCall.WaiterProvider.AddToRolePolicy(map[string]interface{}{
		"Effect": jsii.String("Allow"),
		"Action": []*string{
			jsii.String("s3:GetObject"),
			jsii.String("s3:ListBucket"),
		},
		"Resource": []*string{
			jsii.String("*"),
		},
	})
}
```

## Properties

- `backoffRate`: number — Backoff between attempts.

  **Default:** 1 (no backoff)

  This is the multiplier by which the retry interval increases
  after each retry attempt.

  By default there is no backoff. Each retry will wait the amount of time
  specified by `interval`.

- `interval`: [Duration](/cdk/api/v2/docs/aws-cdk-lib.Duration.html) = Duration.seconds(5) — The interval (number of seconds) to wait between attempts.

- `providerLogLevel`: [ApplicationLogLevel](/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.ApplicationLogLevel.html) = ApplicationLogLevel.FATAL — The log level of the provider lambda function.

- `totalTimeout`: [Duration](/cdk/api/v2/docs/aws-cdk-lib.Duration.html) = Duration.minutes(30) — The total time that the state machine will wait for a successful response.
