Module aws_sdk_apigateway::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).

• EndpointConfiguration

  The endpoint configuration to indicate the types of endpoints an API (RestApi) or its custom domain name (DomainName) has.

• 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

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