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

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

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

• HttpRequestMethodConditionConfig

  Information about an HTTP method condition.

• Limit

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

• Listener

  Information about a listener.

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

• MutualAuthenticationAttributes

  Information about the mutual authentication attributes of a listener.

• PathPatternConditionConfig

  Information about a path pattern condition.

• QueryStringConditionConfig

  Information about a query string condition.

• QueryStringKeyValuePair

  Information about a key/value pair.

• RedirectActionConfig

  Information about a redirect action.

• RevocationContent

  Information about a revocation file.

• Rule

  Information about a rule.

• RuleCondition

  Information about a condition for a rule.

• RulePriorityPair

  Information about the priorities for the rules for a listener.

• SourceIpConditionConfig

  Information about a source IP condition.

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

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