Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS Lambda can respond with.

Structs

AccountLimit

Limits that are related to concurrency and storage. All file and storage sizes are in bytes.

AccountUsage

The number of functions and amount of storage in use.

AliasConfiguration

Provides configuration information about a Lambda function alias.

AliasRoutingConfiguration

The traffic-shifting configuration of a Lambda function alias.

AllowedPublishers

List of signing profiles that can sign a code package.

AmazonManagedKafkaEventSourceConfig

Specific configuration settings for an Amazon Managed Streaming for Apache Kafka (Amazon MSK) event source.

CallbackDetails

Contains details about a callback operation in a durable execution, including the callback token and timeout configuration.

CallbackFailedDetails

Contains details about a failed callback operation, including error information and the reason for failure.

CallbackOptions

Configuration options for callback operations in durable executions, including timeout settings and retry behavior.

CallbackStartedDetails

Contains details about a callback operation that has started, including timing information and callback metadata.

CallbackSucceededDetails

Contains details about a successfully completed callback operation, including the result data and completion timestamp.

CallbackTimedOutDetails

Contains details about a callback operation that timed out, including timeout duration and any partial results.

CapacityProvider

A capacity provider manages compute resources for Lambda functions.

CapacityProviderConfig

Configuration for the capacity provider that manages compute resources for Lambda functions.

CapacityProviderPermissionsConfig

Configuration that specifies the permissions required for the capacity provider to manage compute resources.

CapacityProviderScalingConfig

Configuration that defines how the capacity provider scales compute instances based on demand and policies.

CapacityProviderVpcConfig

VPC configuration that specifies the network settings for compute instances managed by the capacity provider.

ChainedInvokeDetails

Contains details about a chained function invocation in a durable execution, including the target function and invocation parameters.

ChainedInvokeFailedDetails

Contains details about a failed chained function invocation, including error information and failure reason.

ChainedInvokeOptions

Configuration options for chained function invocations in durable executions, including retry settings and timeout configuration.

ChainedInvokeStartedDetails

Contains details about a chained function invocation that has started execution, including start time and execution context.

ChainedInvokeStoppedDetails

Details about a chained invocation that was stopped.

ChainedInvokeSucceededDetails

Details about a chained invocation that succeeded.

ChainedInvokeTimedOutDetails

Details about a chained invocation that timed out.

CheckpointUpdatedExecutionState

Contains operations that have been updated since the last checkpoint, such as completed asynchronous work like timers or callbacks.

CodeSigningConfig

Details about a Code signing configuration.

CodeSigningPolicies

Code signing configuration policies specify the validation failure action for signature mismatch or expiry.

Concurrency

ContextDetails

Details about a durable execution context.

ContextFailedDetails

Details about a context that failed.

ContextOptions

Configuration options for a durable execution context.

ContextStartedDetails

Details about a context that has started.

ContextSucceededDetails

Details about a context that succeeded.

Cors

The cross-origin resource sharing (CORS) settings for your Lambda function URL. Use CORS to grant access to your function URL from any origin. You can also use CORS to control access for specific HTTP headers and methods in requests to your function URL.

DeadLetterConfig

The dead-letter queue for failed asynchronous invocations.

DestinationConfig

A configuration object that specifies the destination of an event after Lambda processes it. For more information, see Adding a destination.

DocumentDbEventSourceConfig

Specific configuration settings for a DocumentDB event source.

DurableConfig

Configuration settings for durable functions, including execution timeout and retention period for execution history.

Environment

A function's environment variable settings. You can use environment variables to adjust your function's behavior without updating code. An environment variable is a pair of strings that are stored in a function's version-specific configuration.

EnvironmentError

Error messages for environment variables that couldn't be applied.

EnvironmentResponse

The results of an operation to update or read environment variables. If the operation succeeds, the response contains the environment variables. If it fails, the response contains details about the error.

EphemeralStorage

The size of the function's /tmp directory in MB. The default value is 512, but can be any whole number between 512 and 10,240 MB. For more information, see Configuring ephemeral storage (console).

ErrorObject

An object that contains error information.

Event

An event that occurred during the execution of a durable function.

EventError

Error information for an event.

EventInput

Input information for an event.

EventResult

Result information for an event.

EventSourceMappingConfiguration

A mapping between an Amazon Web Services resource and a Lambda function. For details, see CreateEventSourceMapping.

EventSourceMappingMetricsConfig

The metrics configuration for your event source. Use this configuration object to define which metrics you want your event source mapping to produce.

Execution

Information about a durable execution.

ExecutionDetails

Details about a durable execution.

ExecutionFailedDetails

Details about a failed durable execution.

ExecutionStartedDetails

Details about a durable execution that started.

ExecutionStoppedDetails

Details about a durable execution that stopped.

ExecutionSucceededDetails

Details about a durable execution that succeeded.

ExecutionTimedOutDetails

Details about a durable execution that timed out.

FileSystemConfig

Details about the connection between a Lambda function and an Amazon EFS file system.

Filter

A structure within a FilterCriteria object that defines an event filtering pattern.

FilterCriteria

An object that contains the filters for an event source.

FilterCriteriaError

An object that contains details about an error related to filter criteria encryption.

FunctionCode

The code for the Lambda function. You can either specify an object in Amazon S3, upload a .zip file archive deployment package directly, or specify the URI of a container image.

FunctionCodeLocation

Details about a function's deployment package.

FunctionConfiguration

Details about a function's configuration.

FunctionEventInvokeConfig

FunctionScalingConfig

Configuration that defines the scaling behavior for a Lambda Managed Instances function, including the minimum and maximum number of execution environments that can be provisioned.

FunctionUrlConfig

Details about a Lambda function URL.

FunctionVersionsByCapacityProviderListItem

Information about a function version that uses a specific capacity provider, including its ARN and current state.

ImageConfig

Configuration values that override the container image Dockerfile settings. For more information, see Container image settings.

ImageConfigError

Error response to GetFunctionConfiguration.

ImageConfigResponse

Response to a GetFunctionConfiguration request.

InstanceRequirements

Specifications that define the characteristics and constraints for compute instances used by the capacity provider.

InvocationCompletedDetails

Details about a function invocation that completed.

InvokeResponseStreamUpdate

A chunk of the streamed response payload.

InvokeWithResponseStreamCompleteEvent

A response confirming that the event stream is complete.

KafkaSchemaRegistryAccessConfig

Specific access configuration settings that tell Lambda how to authenticate with your schema registry.

If you're working with an Glue schema registry, don't provide authentication details in this object. Instead, ensure that your execution role has the required permissions for Lambda to access your cluster.

If you're working with a Confluent schema registry, choose the authentication method in the Type field, and provide the Secrets Manager secret ARN in the URI field.

KafkaSchemaRegistryConfig

Specific configuration settings for a Kafka schema registry.

KafkaSchemaValidationConfig

Specific schema validation configuration settings that tell Lambda the message attributes you want to validate and filter using your schema registry.

LambdaManagedInstancesCapacityProviderConfig

Configuration for Lambda-managed instances used by the capacity provider.

Layer

An Lambda layer.

LayerVersionContentInput

A ZIP archive that contains the contents of an Lambda layer. You can specify either an Amazon S3 location, or upload a layer archive directly.

LayerVersionContentOutput

Details about a version of an Lambda layer.

LayerVersionsListItem

Details about a version of an Lambda layer.

LayersListItem

Details about an Lambda layer.

LoggingConfig

The function's Amazon CloudWatch Logs configuration settings.

OnFailure

A destination for events that failed processing. For more information, see Adding a destination.

OnSuccess

A destination for events that were processed successfully.

To retain records of successful asynchronous invocations, you can configure an Amazon SNS topic, Amazon SQS queue, Lambda function, or Amazon EventBridge event bus as the destination.

OnSuccess is not supported in CreateEventSourceMapping or UpdateEventSourceMapping requests.

Operation

Information about an operation within a durable execution.

OperationUpdate

An update to be applied to an operation during checkpointing.

ProvisionedConcurrencyConfigListItem

Details about the provisioned concurrency configuration for a function alias or version.

ProvisionedPollerConfig

The provisioned mode configuration for the event source. Use Provisioned Mode to customize the minimum and maximum number of event pollers for your event source.

RetryDetails

Information about retry attempts for an operation.

RuntimeVersionConfig

The ARN of the runtime and any errors that occured.

RuntimeVersionError

Any error returned when the runtime version information for the function could not be retrieved.

ScalingConfig

(Amazon SQS only) The scaling configuration for the event source. To remove the configuration, pass an empty value.

SelfManagedEventSource

The self-managed Apache Kafka cluster for your event source.

SelfManagedKafkaEventSourceConfig

Specific configuration settings for a self-managed Apache Kafka event source.

SnapStart

The function's Lambda SnapStart setting. Set ApplyOn to PublishedVersions to create a snapshot of the initialized execution environment when you publish a function version.

SnapStartResponse

The function's SnapStart setting.

SourceAccessConfiguration

To secure and define access to your event source, you can specify the authentication protocol, VPC components, or virtual host.

StepDetails

Details about a step operation.

StepFailedDetails

Details about a step that failed.

StepOptions

Configuration options for a step operation.

StepStartedDetails

Details about a step that has started.

StepSucceededDetails

Details about a step that succeeded.

TagsError

An object that contains details about an error related to retrieving tags.

TargetTrackingScalingPolicy

A scaling policy for the capacity provider that automatically adjusts capacity to maintain a target value for a specific metric.

TenancyConfig

Specifies the tenant isolation mode configuration for a Lambda function. This allows you to configure specific tenant isolation strategies for your function invocations. Tenant isolation configuration cannot be modified after function creation.

TraceHeader

Contains trace headers for the Lambda durable execution.

TracingConfig

The function's X-Ray tracing configuration. To sample and record incoming requests, set Mode to Active.

TracingConfigResponse

The function's X-Ray tracing configuration.

VpcConfig

The VPC security groups and subnets that are attached to a Lambda function. For more information, see Configuring a Lambda function to access resources in a VPC.

VpcConfigResponse

The VPC security groups and subnets that are attached to a Lambda function.

WaitCancelledDetails

Details about a wait operation that was cancelled.

WaitDetails

Details about a wait operation.

WaitOptions

Specifies how long to pause the durable execution.

WaitStartedDetails

Details about a wait operation that has started.

WaitSucceededDetails

Details about a wait operation that succeeded.

Enums

ApplicationLogLevel

When writing a match expression against ApplicationLogLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Architecture

When writing a match expression against Architecture, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CapacityProviderPredefinedMetricType

When writing a match expression against CapacityProviderPredefinedMetricType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CapacityProviderScalingMode

When writing a match expression against CapacityProviderScalingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CapacityProviderState

When writing a match expression against CapacityProviderState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CodeSigningPolicy

When writing a match expression against CodeSigningPolicy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EndPointType

When writing a match expression against EndPointType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EventSourceMappingMetric

When writing a match expression against EventSourceMappingMetric, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EventSourcePosition

When writing a match expression against EventSourcePosition, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EventType

When writing a match expression against EventType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ExecutionStatus

When writing a match expression against ExecutionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FullDocument

When writing a match expression against FullDocument, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FunctionResponseType

When writing a match expression against FunctionResponseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FunctionUrlAuthType

When writing a match expression against FunctionUrlAuthType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FunctionVersion

When writing a match expression against FunctionVersion, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FunctionVersionLatestPublished

When writing a match expression against FunctionVersionLatestPublished, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InvocationType

When writing a match expression against InvocationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InvokeMode

When writing a match expression against InvokeMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InvokeWithResponseStreamResponseEvent

An object that includes a chunk of the response payload. When the stream has ended, Lambda includes a InvokeComplete object.

KafkaSchemaRegistryAuthType

When writing a match expression against KafkaSchemaRegistryAuthType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

KafkaSchemaValidationAttribute

When writing a match expression against KafkaSchemaValidationAttribute, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LastUpdateStatus

When writing a match expression against LastUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LastUpdateStatusReasonCode

When writing a match expression against LastUpdateStatusReasonCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LogFormat

When writing a match expression against LogFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LogType

When writing a match expression against LogType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OperationAction

When writing a match expression against OperationAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OperationStatus

When writing a match expression against OperationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OperationType

When writing a match expression against OperationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PackageType

When writing a match expression against PackageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ProvisionedConcurrencyStatusEnum

When writing a match expression against ProvisionedConcurrencyStatusEnum, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

RecursiveLoop

When writing a match expression against RecursiveLoop, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResponseStreamingInvocationType

When writing a match expression against ResponseStreamingInvocationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Runtime

When writing a match expression against Runtime, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SchemaRegistryEventRecordFormat

When writing a match expression against SchemaRegistryEventRecordFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SnapStartApplyOn

When writing a match expression against SnapStartApplyOn, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SnapStartOptimizationStatus

When writing a match expression against SnapStartOptimizationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SourceAccessType

When writing a match expression against SourceAccessType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

State

When writing a match expression against State, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

StateReasonCode

When writing a match expression against StateReasonCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SystemLogLevel

When writing a match expression against SystemLogLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TenantIsolationMode

When writing a match expression against TenantIsolationMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ThrottleReason

When writing a match expression against ThrottleReason, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TracingMode

When writing a match expression against TracingMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UpdateRuntimeOn

When writing a match expression against UpdateRuntimeOn, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.