Module types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Elastic Load Balancing can respond with.

Structs

• Action

  Information about an action.

  Each rule must include exactly one of the following types of actions: forward, fixed-response, or redirect, and it must be the last action to be performed.

• AdministrativeOverride

  Information about the override status applied to a target.

• AnomalyDetection

  Information about anomaly detection and mitigation.

• AuthenticateCognitoActionConfig

  Request parameters to use when integrating with Amazon Cognito to authenticate users.

• AuthenticateOidcActionConfig

  Request parameters when using an identity provider (IdP) that is compliant with OpenID Connect (OIDC) to authenticate users.

• AvailabilityZone

  Information about an Availability Zone.

• CapacityReservationStatus

  The status of a capacity reservation.

• Certificate

  Information about an SSL server certificate.

• Cipher

  Information about a cipher used in a policy.

• DescribeTrustStoreRevocation

  Information about the revocations used by a trust store.

• FixedResponseActionConfig

  Information about an action that returns a custom HTTP response.

• ForwardActionConfig

  Information about a forward action.

• HostHeaderConditionConfig

  Information about a host header condition.

• HttpHeaderConditionConfig

  Information about an HTTP header condition.

  There is a set of standard HTTP header fields. You can also define custom HTTP header fields.

• HttpRequestMethodConditionConfig

  Information about an HTTP method condition.

  HTTP defines a set of request methods, also referred to as HTTP verbs. For more information, see the HTTP Method Registry. You can also define custom HTTP methods.

• Limit

  Information about an Elastic Load Balancing resource limit for your Amazon Web Services account.

  For more information, see the following:

  • Quotas for your Application Load Balancers

  • Quotas for your Network Load Balancers

  • Quotas for your Gateway Load Balancers

• Listener

  Information about a listener.

• ListenerAttribute

  Information about a listener attribute.

• LoadBalancer

  Information about a load balancer.

• LoadBalancerAddress

  Information about a static IP address for a load balancer.

• LoadBalancerAttribute

  Information about a load balancer attribute.

• LoadBalancerState

  Information about the state of the load balancer.

• Matcher

  The codes to use when checking for a successful response from a target. If the protocol version is gRPC, these are gRPC codes. Otherwise, these are HTTP codes.

• MinimumLoadBalancerCapacity

  The minimum capacity for a load balancer.

• MutualAuthenticationAttributes

  Information about the mutual authentication attributes of a listener.

• PathPatternConditionConfig

  Information about a path pattern condition.

• QueryStringConditionConfig

  Information about a query string condition.

  The query string component of a URI starts after the first '?' character and is terminated by either a '#' character or the end of the URI. A typical query string contains key/value pairs separated by '&' characters. The allowed characters are specified by RFC 3986. Any character can be percentage encoded.

• QueryStringKeyValuePair

  Information about a key/value pair.

• RedirectActionConfig

  Information about a redirect action.

  A URI consists of the following components: protocol://hostname:port/path?query. You must modify at least one of the following components to avoid a redirect loop: protocol, hostname, port, or path. Any components that you do not modify retain their original values.

  You can reuse URI components using the following reserved keywords:

  • #{protocol}

  • #{host}

  • #{port}

  • #{path} (the leading "/" is removed)

  • #{query}

  For example, you can change the path to "/new/#{path}", the hostname to "example.#{host}", or the query to "#{query}&value=xyz".

• RevocationContent

  Information about a revocation file.

• Rule

  Information about a rule.

• RuleCondition

  Information about a condition for a rule.

  Each rule can optionally include up to one of each of the following conditions: http-request-method, host-header, path-pattern, and source-ip. Each rule can also optionally include one or more of each of the following conditions: http-header and query-string. Note that the value for a condition can't be empty.

  For more information, see Quotas for your Application Load Balancers.

• RulePriorityPair

  Information about the priorities for the rules for a listener.

• SourceIpConditionConfig

  Information about a source IP condition.

  You can use this condition to route based on the IP address of the source that connects to the load balancer. If a client is behind a proxy, this is the IP address of the proxy not the IP address of the client.

• SslPolicy

  Information about a policy used for SSL negotiation.

• SubnetMapping

  Information about a subnet mapping.

• Tag

  Information about a tag.

• TagDescription

  The tags associated with a resource.

• TargetDescription

  Information about a target.

• TargetGroup

  Information about a target group.

• TargetGroupAttribute

  Information about a target group attribute.

• TargetGroupStickinessConfig

  Information about the target group stickiness for a rule.

• TargetGroupTuple

  Information about how traffic will be distributed between multiple target groups in a forward rule.

• TargetHealth

  Information about the current health of a target.

• TargetHealthDescription

  Information about the health of a target.

• TrustStore

  Information about a trust store.

• TrustStoreAssociation

  Information about the resources a trust store is associated with.

• TrustStoreRevocation

  Information about a revocation file in use by a trust store.

• ZonalCapacityReservationState

  The capacity reservation status for each availability zone.

Enums

• ActionTypeEnum
  When writing a match expression against ActionTypeEnum, 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.
• AnomalyResultEnum
  When writing a match expression against AnomalyResultEnum, 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.
• AuthenticateCognitoActionConditionalBehaviorEnum
  When writing a match expression against AuthenticateCognitoActionConditionalBehaviorEnum, 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.
• AuthenticateOidcActionConditionalBehaviorEnum
  When writing a match expression against AuthenticateOidcActionConditionalBehaviorEnum, 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.
• CapacityReservationStateEnum
  When writing a match expression against CapacityReservationStateEnum, 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.
• DescribeTargetHealthInputIncludeEnum
  When writing a match expression against DescribeTargetHealthInputIncludeEnum, 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.
• EnablePrefixForIpv6SourceNatEnum
  When writing a match expression against EnablePrefixForIpv6SourceNatEnum, 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.
• EnforceSecurityGroupInboundRulesOnPrivateLinkTrafficEnum
  When writing a match expression against EnforceSecurityGroupInboundRulesOnPrivateLinkTrafficEnum, 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.
• LoadBalancerSchemeEnum
  When writing a match expression against LoadBalancerSchemeEnum, 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.
• LoadBalancerStateEnum
  When writing a match expression against LoadBalancerStateEnum, 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.
• LoadBalancerTypeEnum
  When writing a match expression against LoadBalancerTypeEnum, 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.
• MitigationInEffectEnum
  When writing a match expression against MitigationInEffectEnum, 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.
• ProtocolEnum
  When writing a match expression against ProtocolEnum, 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.
• RedirectActionStatusCodeEnum
  When writing a match expression against RedirectActionStatusCodeEnum, 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.
• RevocationType
  When writing a match expression against RevocationType, 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.
• TargetAdministrativeOverrideReasonEnum
  When writing a match expression against TargetAdministrativeOverrideReasonEnum, 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.
• TargetAdministrativeOverrideStateEnum
  When writing a match expression against TargetAdministrativeOverrideStateEnum, 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.
• TargetGroupIpAddressTypeEnum
  When writing a match expression against TargetGroupIpAddressTypeEnum, 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.
• TargetHealthReasonEnum
  When writing a match expression against TargetHealthReasonEnum, 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.
• TargetHealthStateEnum
  When writing a match expression against TargetHealthStateEnum, 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.
• TargetTypeEnum
  When writing a match expression against TargetTypeEnum, 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.
• TrustStoreAssociationStatusEnum
  When writing a match expression against TrustStoreAssociationStatusEnum, 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.
• TrustStoreStatus
  When writing a match expression against TrustStoreStatus, 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.