Module aws_sdk_lambda::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.

• CodeSigningConfig

  Details about a Code signing configuration.

• CodeSigningPolicies

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

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

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

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

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

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

• OnSuccess

  A destination for events that were processed successfully.

• ProvisionedConcurrencyConfigListItem

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

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

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

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