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

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