Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AmazonApiGatewayV2 can respond with.

Structs

AccessLogSettings

Settings for logging access in a stage.

Api

Represents an API.

ApiMapping

Represents an API mapping.

Authorizer

Represents an authorizer.

Cors

Represents a CORS configuration. Supported only for HTTP APIs. See Configuring CORS for more information.

Deployment

An immutable representation of an API that can be called by users. A Deployment must be associated with a Stage for it to be callable over the internet.

DomainName

Represents a domain name.

DomainNameConfiguration

The domain name configuration.

Integration

Represents an integration.

IntegrationResponse

Represents an integration response.

JwtConfiguration

Represents the configuration of a JWT authorizer. Required for the JWT authorizer type. Supported only for HTTP APIs.

Model

Represents a data model for an API. Supported only for WebSocket APIs. See Create Models and Mapping Templates for Request and Response Mappings.

MutualTlsAuthentication

MutualTlsAuthenticationInput

ParameterConstraints

Validation constraints imposed on parameters of a request (path, query string, headers).

Route

Represents a route.

RouteResponse

Represents a route response.

RouteSettings

Represents a collection of route settings.

RoutingRule

Represents a routing rule.

RoutingRuleAction

The routing rule action.

RoutingRuleActionInvokeApi

Represents an InvokeApi action.

RoutingRuleCondition

Represents a routing rule condition.

RoutingRuleMatchBasePaths

Represents a MatchBasePaths condition.

RoutingRuleMatchHeaderValue

Represents a MatchHeaderValue.

RoutingRuleMatchHeaders

Represents a MatchHeaders condition.

Stage

Represents an API stage.

TlsConfig

The TLS configuration for a private integration. If you specify a TLS configuration, private integration traffic uses the HTTPS protocol. Supported only for HTTP APIs.

TlsConfigInput

The TLS configuration for a private integration. If you specify a TLS configuration, private integration traffic uses the HTTPS protocol. Supported only for HTTP APIs.

VpcLink

Represents a VPC link.

Enums

AuthorizationType

When writing a match expression against AuthorizationType, 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.

AuthorizerType

When writing a match expression against AuthorizerType, 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.

ConnectionType

When writing a match expression against ConnectionType, 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.

ContentHandlingStrategy

When writing a match expression against ContentHandlingStrategy, 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.

DeploymentStatus

When writing a match expression against DeploymentStatus, 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.

DomainNameStatus

When writing a match expression against DomainNameStatus, 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.

IntegrationType

When writing a match expression against IntegrationType, 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.

IpAddressType

When writing a match expression against IpAddressType, 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.

LoggingLevel

When writing a match expression against LoggingLevel, 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.

PassthroughBehavior

When writing a match expression against PassthroughBehavior, 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.

ProtocolType

When writing a match expression against ProtocolType, 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.

RoutingMode

When writing a match expression against RoutingMode, 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.

SecurityPolicy

When writing a match expression against SecurityPolicy, 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.

VpcLinkStatus

When writing a match expression against VpcLinkStatus, 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.

VpcLinkVersion

When writing a match expression against VpcLinkVersion, 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.