All Classes and Interfaces
Class
Description
Batches API requests to optimize throughput by grouping individual calls into batch operations.
Input for the approval workflow.
Handle for an asynchronously executing durable function.
Jackson module that registers custom serializers and deserializers for AWS SDK v2 model classes.
Base class for all durable operations (STEP, WAIT, etc.).
Configuration for callback operations.
Builder for
CallbackConfig.Example demonstrating callback operations for external system integration.
Thrown when a callback operation encounters an error.
Exception thrown when a callback fails due to an error from the external system.
Durable operation for creating and waiting on external callbacks.
Exception thrown when a callback submitter step fails to submit a callback.
Exception thrown when a callback times out.
Example demonstrating child context workflows with the Durable Execution SDK.
Exception thrown when a child context fails and the original exception cannot be reconstructed.
Manages the lifecycle of a child execution context.
Test runner for durable Lambda functions deployed to AWS.
A
DurableFuture that is already completed with a value.Controls when a concurrent operation (map or parallel) completes.
Example demonstrating advanced map features: wait operations inside branches, error handling, and early termination.
Abstract base class for concurrent execution of multiple child context operations.
Example demonstrating concurrent waitForCondition operations using map.
Example demonstrating custom configuration with both custom HTTP client and custom SerDes.
Custom data class with camelCase field names to demonstrate snake_case serialization.
Example demonstrating custom polling strategy configuration.
Example demonstrating the map operation with the Durable Execution SDK.
Example demonstrating parallel branch execution with the Durable Execution SDK.
Result of creating a callback, containing the callback ID and providing access to the result.
Configuration for DurableHandler initialization.
Builder for DurableConfig.
Function applied to each item in a map operation.
User-facing API for defining durable operations within a workflow.
Client interface for communicating with the Lambda Durable Functions backend.
Base exception for all durable execution errors.
Input payload received by the Lambda handler from the Durable Functions backend.
Output payload returned by the Lambda handler to the Durable Functions backend.
Orchestrates the lifecycle of a durable execution.
A future representing the result of an asynchronous durable operation.
Abstract base class for Lambda handlers that use durable execution.
Serializer/Deserializer for Durable Execution Input and Output objects.
Logger wrapper that adds durable execution context to log entries via MDC and optionally suppresses logs during
replay.
Exception associated with a specific durable operation, carrying the operation and error details.
Example demonstrating error handling patterns with the Durable Execution SDK.
Custom exception to demonstrate that original exception types are preserved across checkpoints.
Utility class for handling exceptions
Central manager for durable execution coordination.
Terminal status of a durable execution.
Example demonstrating a durable Lambda function that uses generic types in input and output.
Example demonstrating TypeToken support for complex generic types.
Processes execution history events from the GetDurableExecutionHistory API into
TestResult objects.Polls the GetDurableExecutionHistory API until execution completes or a timeout is reached.
An illegal operation is detected.
Configuration for chained invoke operations.
Builder for creating InvokeConfig instances.
Base exception for chained invoke operation failures.
Thrown when a chained invoke operation fails with an error in the invoked function.
Durable operation that invokes another Lambda function and waits for its result.
Thrown when a chained invoke operation is stopped before completion.
Thrown when a chained invoke operation exceeds its timeout.
Jackson-based implementation of
SerDes.Jitter strategy for retry delays to prevent thundering herd problems.
Default implementation of
DurableExecutionClient backed by the AWS Lambda SDK client.In-memory test runner for durable Lambda functions.
In-memory implementation of
DurableExecutionClient for local testing.Configuration for DurableLogger behavior.
Example demonstrating DurableLogger usage for structured logging with execution context.
Performance test example demonstrating concurrent async child contexts.
Performance test example demonstrating concurrent async steps.
Configuration for map operations.
Builder for creating MapConfig instances.
Thrown when a map iteration fails and deserialization of the original exception also fails.
Executes a map operation: applies a function to each item in a collection concurrently, with each item running in its
own child context.
Result container for map operations.
Error details for a failed map item.
Represents the outcome of a single item in a map operation.
Status of an individual map item.
Exception thrown when non-deterministic code is detected during replay.
Simple example demonstrating a durable function doesn't have any durable operation
Identifies a durable operation by its unique ID, human-readable name, type, and optional sub-type.
Generates operation IDs for the durable operations.
The operation status and result/error from Step, Context, Callback and ChainedInvoke operations
Fine-grained classification of durable operations beyond the basic operation types.
Configuration options for parallel branch in durable executions.
Builder for creating StepConfig instances.
Thrown when a parallel branch fails and deserialization of the original exception also fails.
Configuration options for parallel operations in durable executions.
Builder for creating ParallelConfig instances.
User-facing context for managing parallel branch execution within a durable function.
Example demonstrating parallel branch execution with the Durable Execution SDK.
Example demonstrating parallel execution with failure tolerance.
Manages parallel execution of multiple branches as child context operations.
Summary result of a parallel operation.
Example demonstrating parallel branches where some branches include wait operations.
Utility class for validating input parameters in the Durable Execution SDK.
Factory class for creating common polling strategies.
Preset polling strategies for common use cases.
Functional interface for computing polling delays between attempts.
Represents a decision about whether to retry a failed operation and how long to wait.
Simple example demonstrating retry strategies with a flaky API.
Example demonstrating in-process retry behavior with concurrent operations.
Factory class for creating common retry strategies.
Preset retry strategies for common use cases.
Functional interface for determining retry behavior when operations fail.
Configuration options for RunInChildContext operations in durable executions.
Builder for creating StepConfig instances.
Interface for serialization and deserialization of objects.
Exception thrown when serialization or deserialization fails.
Base class for all durable operations (STEP, WAIT, etc.).
Simple example demonstrating basic invoke execution with the Durable Execution SDK.
Example demonstrating the map operation with the Durable Execution SDK.
Simple example demonstrating basic step execution with the Durable Execution SDK.
Configuration options for step operations in durable executions.
Builder for creating StepConfig instances.
Context available inside a step operation's user function.
Base exception for step operation failures.
Thrown when a step operation fails after exhausting all retry attempts.
Exception thrown when a step with AT_MOST_ONCE_PER_RETRY semantics was started but interrupted before completion.
Durable operation that executes a user-provided function with retry support.
Delivery semantics for step operations.
Exception thrown to suspend execution during wait operations.
Wrapper for AWS SDK Operation providing convenient access methods.
Represents the result of a durable execution, providing access to the execution status, output, operations, and
history events.
Holds the current thread's execution context.
Thread type enum for tracking conceptual threads in durable execution.
Framework-agnostic type token for capturing generic type information at runtime.
Exception thrown when the execution is not recoverable.
Example demonstrating non-blocking wait with waitAsync().
Example demonstrating concurrent stepAsync() with wait() operations.
Example demonstrating concurrent stepAsync() with wait() operations where no suspension occurs.
Example demonstrating step execution with wait operations.
Configuration for the
waitForCallback composite operation.Builder for
WaitForCallbackConfig.Configuration for
waitForCondition operations.Example demonstrating the waitForCondition operation.
Exception thrown when a
waitForCondition operation fails.Durable operation that periodically checks a user-supplied condition function, using a configurable wait strategy to
determine polling intervals and termination.
Result returned by a WaitForCondition check function to signal whether the condition is met.
Strategy that computes the delay before the next polling attempt in a
waitForCondition operation.Durable operation that suspends execution for a specified duration without consuming compute.
Factory class for creating common
WaitForConditionWaitStrategy implementations.Preset wait strategies for common use cases.