Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon API Gateway can respond with.

Structs

AccessLogSettings

Access log settings, including the access log format and access log destination ARN.

ApiKey

A resource that can be distributed to callers for executing Method resources that require an API key. API keys can be mapped to any Stage on any RestApi, which indicates that the callers with the API key can make requests to that stage.

ApiStage

API stage name of the associated API stage in a usage plan.

Authorizer

Represents an authorization layer for methods. If enabled on a method, API Gateway will activate the authorizer when a client calls the method.

BasePathMapping

Represents the base path that callers of the API must provide as part of the URL after the domain name.

CanarySettings

Configuration settings of a canary deployment.

ClientCertificate

Represents a client certificate used to configure client-side SSL authentication while sending requests to the integration endpoint.

Deployment

An immutable representation of a RestApi resource that can be called by users using Stages. A deployment must be associated with a Stage for it to be callable over the Internet.

DeploymentCanarySettings

The input configuration for a canary deployment.

DocumentationPart

A documentation part for a targeted API entity.

DocumentationPartLocation

Specifies the target API entity to which the documentation applies.

DocumentationVersion

A snapshot of the documentation of an API.

DomainName

Represents a custom domain name as a user-friendly host name of an API (RestApi).

DomainNameAccessAssociation

Represents a domain name access association between an access association source and a private custom domain name. With a domain name access association, an access association source can invoke a private custom domain name while isolated from the public internet.

EndpointConfiguration

The endpoint configuration to indicate the types of endpoints an API (RestApi) or its custom domain name (DomainName) has and the IP address types that can invoke it.

GatewayResponse

A gateway response of a given response type and status code, with optional response parameters and mapping templates.

Integration

Represents an HTTP, HTTP_PROXY, AWS, AWS_PROXY, or Mock integration.

IntegrationResponse

Represents an integration response. The status code must map to an existing MethodResponse, and parameters and templates can be used to transform the back-end response.

Method

Represents a client-facing interface by which the client calls the API to access back-end resources. A Method resource is integrated with an Integration resource. Both consist of a request and one or more responses. The method request takes the client input that is passed to the back end through the integration request. A method response returns the output from the back end to the client through an integration response. A method request is embodied in a Method resource, whereas an integration request is embodied in an Integration resource. On the other hand, a method response is represented by a MethodResponse resource, whereas an integration response is represented by an IntegrationResponse resource.

MethodResponse

Represents a method response of a given HTTP status code returned to the client. The method response is passed from the back end through the associated integration response that can be transformed using a mapping template.

MethodSetting

Specifies the method setting properties.

MethodSnapshot

Represents a summary of a Method resource, given a particular date and time.

Model

Represents the data structure of a method's request or response payload.

MutualTlsAuthentication

The mutual TLS authentication configuration for a custom domain name. If specified, API Gateway performs two-way authentication between the client and the server. Clients must present a trusted certificate to access your API.

MutualTlsAuthenticationInput

The mutual TLS authentication configuration for a custom domain name. If specified, API Gateway performs two-way authentication between the client and the server. Clients must present a trusted certificate to access your API.

PatchOperation

For more information about supported patch operations, see Patch Operations.

QuotaSettings

Quotas configured for a usage plan.

RequestValidator

A set of validation rules for incoming Method requests.

Resource

Represents an API resource.

RestApi

Represents a REST API.

SdkConfigurationProperty

A configuration property of an SDK type.

SdkType

A type of SDK that API Gateway can generate.

Stage

Represents a unique identifier for a version of a deployed RestApi that is callable by users.

StageKey

A reference to a unique stage identified in the format {restApiId}/{stage}.

ThrottleSettings

The API request rate limits.

TlsConfig

Specifies the TLS configuration for an integration.

UsagePlan

Represents a usage plan used to specify who can assess associated API stages. Optionally, target request rate and quota limits can be set. In some cases clients can exceed the targets that you set. Don’t rely on usage plans to control costs. Consider using Amazon Web Services Budgets to monitor costs and WAF to manage API requests.

UsagePlanKey

Represents a usage plan key to identify a plan customer.

VpcLink

An API Gateway VPC link for a RestApi to access resources in an Amazon Virtual Private Cloud (VPC).

Enums

AccessAssociationSourceType

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

ApiKeySourceType

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

ApiKeysFormat

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

CacheClusterSize

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

CacheClusterStatus

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

DocumentationPartType

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

GatewayResponseType

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

LocationStatusType

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

Op

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

PutMode

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

QuotaPeriodType

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

ResourceOwner

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

UnauthorizedCacheControlHeaderStrategy

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