Module types

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.

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).

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.

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

FunctionUrlConfig

Details about a Lambda function URL.

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.

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.

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.

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. An event poller is a compute unit that provides approximately 5 MBps of throughput.

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.

TagsError

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

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.

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.
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.
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.
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.
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.
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.

Module types

Module types Copy item path

Modules§

Structs§

Enums§

Module types