Documentation

Overview

Package elbv2 provides the client and types for making API requests to Elastic Load Balancing.

A load balancer distributes incoming traffic across targets, such as your EC2 instances. This enables you to increase the availability of your application. The load balancer also monitors the health of its registered targets and ensures that it routes traffic only to healthy targets. You configure your load balancer to accept incoming traffic by specifying one or more listeners, which are configured with a protocol and port number for connections from clients to the load balancer. You configure a target group with a protocol and port number for connections from the load balancer to the targets, and with health check settings to be used when checking the health status of the targets.

Elastic Load Balancing supports the following types of load balancers: Application Load Balancers, Network Load Balancers, Gateway Load Balancers, and Classic Load Balancers. This reference covers the following load balancer types:

* Application Load Balancer - Operates at the application layer (layer
7) and supports HTTP and HTTPS.

* Network Load Balancer - Operates at the transport layer (layer 4) and
supports TCP, TLS, and UDP.

* Gateway Load Balancer - Operates at the network layer (layer 3).

For more information, see the Elastic Load Balancing User Guide (https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).

All Elastic Load Balancing operations are idempotent, which means that they complete at most one time. If you repeat an operation, it succeeds.

See https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01 for more information on this service.

See elbv2 package documentation for more information. https://docs.aws.amazon.com/sdk-for-go/api/service/elbv2/

Using the Client

To contact Elastic Load Balancing with the SDK use the New function to create a new service client. With that client you can make API requests to the service. These clients are safe to use concurrently.

See the SDK's documentation for more information on how to use the SDK. https://docs.aws.amazon.com/sdk-for-go/api/

See aws.Config documentation for more information on configuring SDK clients. https://docs.aws.amazon.com/sdk-for-go/api/aws/#Config

See the Elastic Load Balancing client ELBV2 for more information on creating client for this service. https://docs.aws.amazon.com/sdk-for-go/api/service/elbv2/#New

Index

Examples

Constants

View Source
const (
	// ActionTypeEnumForward is a ActionTypeEnum enum value
	ActionTypeEnumForward = "forward"

	// ActionTypeEnumAuthenticateOidc is a ActionTypeEnum enum value
	ActionTypeEnumAuthenticateOidc = "authenticate-oidc"

	// ActionTypeEnumAuthenticateCognito is a ActionTypeEnum enum value
	ActionTypeEnumAuthenticateCognito = "authenticate-cognito"

	// ActionTypeEnumRedirect is a ActionTypeEnum enum value
	ActionTypeEnumRedirect = "redirect"

	// ActionTypeEnumFixedResponse is a ActionTypeEnum enum value
	ActionTypeEnumFixedResponse = "fixed-response"
)
View Source
const (
	// AuthenticateCognitoActionConditionalBehaviorEnumDeny is a AuthenticateCognitoActionConditionalBehaviorEnum enum value
	AuthenticateCognitoActionConditionalBehaviorEnumDeny = "deny"

	// AuthenticateCognitoActionConditionalBehaviorEnumAllow is a AuthenticateCognitoActionConditionalBehaviorEnum enum value
	AuthenticateCognitoActionConditionalBehaviorEnumAllow = "allow"

	// AuthenticateCognitoActionConditionalBehaviorEnumAuthenticate is a AuthenticateCognitoActionConditionalBehaviorEnum enum value
	AuthenticateCognitoActionConditionalBehaviorEnumAuthenticate = "authenticate"
)
View Source
const (
	// AuthenticateOidcActionConditionalBehaviorEnumDeny is a AuthenticateOidcActionConditionalBehaviorEnum enum value
	AuthenticateOidcActionConditionalBehaviorEnumDeny = "deny"

	// AuthenticateOidcActionConditionalBehaviorEnumAllow is a AuthenticateOidcActionConditionalBehaviorEnum enum value
	AuthenticateOidcActionConditionalBehaviorEnumAllow = "allow"

	// AuthenticateOidcActionConditionalBehaviorEnumAuthenticate is a AuthenticateOidcActionConditionalBehaviorEnum enum value
	AuthenticateOidcActionConditionalBehaviorEnumAuthenticate = "authenticate"
)
View Source
const (
	// IpAddressTypeIpv4 is a IpAddressType enum value
	IpAddressTypeIpv4 = "ipv4"

	// IpAddressTypeDualstack is a IpAddressType enum value
	IpAddressTypeDualstack = "dualstack"
)
View Source
const (
	// LoadBalancerSchemeEnumInternetFacing is a LoadBalancerSchemeEnum enum value
	LoadBalancerSchemeEnumInternetFacing = "internet-facing"

	// LoadBalancerSchemeEnumInternal is a LoadBalancerSchemeEnum enum value
	LoadBalancerSchemeEnumInternal = "internal"
)
View Source
const (
	// LoadBalancerStateEnumActive is a LoadBalancerStateEnum enum value
	LoadBalancerStateEnumActive = "active"

	// LoadBalancerStateEnumProvisioning is a LoadBalancerStateEnum enum value
	LoadBalancerStateEnumProvisioning = "provisioning"

	// LoadBalancerStateEnumActiveImpaired is a LoadBalancerStateEnum enum value
	LoadBalancerStateEnumActiveImpaired = "active_impaired"

	// LoadBalancerStateEnumFailed is a LoadBalancerStateEnum enum value
	LoadBalancerStateEnumFailed = "failed"
)
View Source
const (
	// LoadBalancerTypeEnumApplication is a LoadBalancerTypeEnum enum value
	LoadBalancerTypeEnumApplication = "application"

	// LoadBalancerTypeEnumNetwork is a LoadBalancerTypeEnum enum value
	LoadBalancerTypeEnumNetwork = "network"

	// LoadBalancerTypeEnumGateway is a LoadBalancerTypeEnum enum value
	LoadBalancerTypeEnumGateway = "gateway"
)
View Source
const (
	// ProtocolEnumHttp is a ProtocolEnum enum value
	ProtocolEnumHttp = "HTTP"

	// ProtocolEnumHttps is a ProtocolEnum enum value
	ProtocolEnumHttps = "HTTPS"

	// ProtocolEnumTcp is a ProtocolEnum enum value
	ProtocolEnumTcp = "TCP"

	// ProtocolEnumTls is a ProtocolEnum enum value
	ProtocolEnumTls = "TLS"

	// ProtocolEnumUdp is a ProtocolEnum enum value
	ProtocolEnumUdp = "UDP"

	// ProtocolEnumTcpUdp is a ProtocolEnum enum value
	ProtocolEnumTcpUdp = "TCP_UDP"

	// ProtocolEnumGeneve is a ProtocolEnum enum value
	ProtocolEnumGeneve = "GENEVE"
)
View Source
const (
	// RedirectActionStatusCodeEnumHttp301 is a RedirectActionStatusCodeEnum enum value
	RedirectActionStatusCodeEnumHttp301 = "HTTP_301"

	// RedirectActionStatusCodeEnumHttp302 is a RedirectActionStatusCodeEnum enum value
	RedirectActionStatusCodeEnumHttp302 = "HTTP_302"
)
View Source
const (
	// TargetHealthReasonEnumElbRegistrationInProgress is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumElbRegistrationInProgress = "Elb.RegistrationInProgress"

	// TargetHealthReasonEnumElbInitialHealthChecking is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumElbInitialHealthChecking = "Elb.InitialHealthChecking"

	// TargetHealthReasonEnumTargetResponseCodeMismatch is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetResponseCodeMismatch = "Target.ResponseCodeMismatch"

	// TargetHealthReasonEnumTargetTimeout is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetTimeout = "Target.Timeout"

	// TargetHealthReasonEnumTargetFailedHealthChecks is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetFailedHealthChecks = "Target.FailedHealthChecks"

	// TargetHealthReasonEnumTargetNotRegistered is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetNotRegistered = "Target.NotRegistered"

	// TargetHealthReasonEnumTargetNotInUse is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetNotInUse = "Target.NotInUse"

	// TargetHealthReasonEnumTargetDeregistrationInProgress is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetDeregistrationInProgress = "Target.DeregistrationInProgress"

	// TargetHealthReasonEnumTargetInvalidState is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetInvalidState = "Target.InvalidState"

	// TargetHealthReasonEnumTargetIpUnusable is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetIpUnusable = "Target.IpUnusable"

	// TargetHealthReasonEnumTargetHealthCheckDisabled is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumTargetHealthCheckDisabled = "Target.HealthCheckDisabled"

	// TargetHealthReasonEnumElbInternalError is a TargetHealthReasonEnum enum value
	TargetHealthReasonEnumElbInternalError = "Elb.InternalError"
)
View Source
const (
	// TargetHealthStateEnumInitial is a TargetHealthStateEnum enum value
	TargetHealthStateEnumInitial = "initial"

	// TargetHealthStateEnumHealthy is a TargetHealthStateEnum enum value
	TargetHealthStateEnumHealthy = "healthy"

	// TargetHealthStateEnumUnhealthy is a TargetHealthStateEnum enum value
	TargetHealthStateEnumUnhealthy = "unhealthy"

	// TargetHealthStateEnumUnused is a TargetHealthStateEnum enum value
	TargetHealthStateEnumUnused = "unused"

	// TargetHealthStateEnumDraining is a TargetHealthStateEnum enum value
	TargetHealthStateEnumDraining = "draining"

	// TargetHealthStateEnumUnavailable is a TargetHealthStateEnum enum value
	TargetHealthStateEnumUnavailable = "unavailable"
)
View Source
const (
	// TargetTypeEnumInstance is a TargetTypeEnum enum value
	TargetTypeEnumInstance = "instance"

	// TargetTypeEnumIp is a TargetTypeEnum enum value
	TargetTypeEnumIp = "ip"

	// TargetTypeEnumLambda is a TargetTypeEnum enum value
	TargetTypeEnumLambda = "lambda"
)
View Source
const (

	// ErrCodeALPNPolicyNotSupportedException for service response error code
	// "ALPNPolicyNotFound".
	//
	// The specified ALPN policy is not supported.
	ErrCodeALPNPolicyNotSupportedException = "ALPNPolicyNotFound"

	// ErrCodeAllocationIdNotFoundException for service response error code
	// "AllocationIdNotFound".
	//
	// The specified allocation ID does not exist.
	ErrCodeAllocationIdNotFoundException = "AllocationIdNotFound"

	// ErrCodeAvailabilityZoneNotSupportedException for service response error code
	// "AvailabilityZoneNotSupported".
	//
	// The specified Availability Zone is not supported.
	ErrCodeAvailabilityZoneNotSupportedException = "AvailabilityZoneNotSupported"

	// ErrCodeCertificateNotFoundException for service response error code
	// "CertificateNotFound".
	//
	// The specified certificate does not exist.
	ErrCodeCertificateNotFoundException = "CertificateNotFound"

	// ErrCodeDuplicateListenerException for service response error code
	// "DuplicateListener".
	//
	// A listener with the specified port already exists.
	ErrCodeDuplicateListenerException = "DuplicateListener"

	// ErrCodeDuplicateLoadBalancerNameException for service response error code
	// "DuplicateLoadBalancerName".
	//
	// A load balancer with the specified name already exists.
	ErrCodeDuplicateLoadBalancerNameException = "DuplicateLoadBalancerName"

	// ErrCodeDuplicateTagKeysException for service response error code
	// "DuplicateTagKeys".
	//
	// A tag key was specified more than once.
	ErrCodeDuplicateTagKeysException = "DuplicateTagKeys"

	// ErrCodeDuplicateTargetGroupNameException for service response error code
	// "DuplicateTargetGroupName".
	//
	// A target group with the specified name already exists.
	ErrCodeDuplicateTargetGroupNameException = "DuplicateTargetGroupName"

	// ErrCodeHealthUnavailableException for service response error code
	// "HealthUnavailable".
	//
	// The health of the specified targets could not be retrieved due to an internal
	// error.
	ErrCodeHealthUnavailableException = "HealthUnavailable"

	// ErrCodeIncompatibleProtocolsException for service response error code
	// "IncompatibleProtocols".
	//
	// The specified configuration is not valid with this protocol.
	ErrCodeIncompatibleProtocolsException = "IncompatibleProtocols"

	// ErrCodeInvalidConfigurationRequestException for service response error code
	// "InvalidConfigurationRequest".
	//
	// The requested configuration is not valid.
	ErrCodeInvalidConfigurationRequestException = "InvalidConfigurationRequest"

	// ErrCodeInvalidLoadBalancerActionException for service response error code
	// "InvalidLoadBalancerAction".
	//
	// The requested action is not valid.
	ErrCodeInvalidLoadBalancerActionException = "InvalidLoadBalancerAction"

	// ErrCodeInvalidSchemeException for service response error code
	// "InvalidScheme".
	//
	// The requested scheme is not valid.
	ErrCodeInvalidSchemeException = "InvalidScheme"

	// ErrCodeInvalidSecurityGroupException for service response error code
	// "InvalidSecurityGroup".
	//
	// The specified security group does not exist.
	ErrCodeInvalidSecurityGroupException = "InvalidSecurityGroup"

	// ErrCodeInvalidSubnetException for service response error code
	// "InvalidSubnet".
	//
	// The specified subnet is out of available addresses.
	ErrCodeInvalidSubnetException = "InvalidSubnet"

	// ErrCodeInvalidTargetException for service response error code
	// "InvalidTarget".
	//
	// The specified target does not exist, is not in the same VPC as the target
	// group, or has an unsupported instance type.
	ErrCodeInvalidTargetException = "InvalidTarget"

	// ErrCodeListenerNotFoundException for service response error code
	// "ListenerNotFound".
	//
	// The specified listener does not exist.
	ErrCodeListenerNotFoundException = "ListenerNotFound"

	// ErrCodeLoadBalancerNotFoundException for service response error code
	// "LoadBalancerNotFound".
	//
	// The specified load balancer does not exist.
	ErrCodeLoadBalancerNotFoundException = "LoadBalancerNotFound"

	// ErrCodeOperationNotPermittedException for service response error code
	// "OperationNotPermitted".
	//
	// This operation is not allowed.
	ErrCodeOperationNotPermittedException = "OperationNotPermitted"

	// ErrCodePriorityInUseException for service response error code
	// "PriorityInUse".
	//
	// The specified priority is in use.
	ErrCodePriorityInUseException = "PriorityInUse"

	// ErrCodeResourceInUseException for service response error code
	// "ResourceInUse".
	//
	// A specified resource is in use.
	ErrCodeResourceInUseException = "ResourceInUse"

	// ErrCodeRuleNotFoundException for service response error code
	// "RuleNotFound".
	//
	// The specified rule does not exist.
	ErrCodeRuleNotFoundException = "RuleNotFound"

	// ErrCodeSSLPolicyNotFoundException for service response error code
	// "SSLPolicyNotFound".
	//
	// The specified SSL policy does not exist.
	ErrCodeSSLPolicyNotFoundException = "SSLPolicyNotFound"

	// ErrCodeSubnetNotFoundException for service response error code
	// "SubnetNotFound".
	//
	// The specified subnet does not exist.
	ErrCodeSubnetNotFoundException = "SubnetNotFound"

	// ErrCodeTargetGroupAssociationLimitException for service response error code
	// "TargetGroupAssociationLimit".
	//
	// You've reached the limit on the number of load balancers per target group.
	ErrCodeTargetGroupAssociationLimitException = "TargetGroupAssociationLimit"

	// ErrCodeTargetGroupNotFoundException for service response error code
	// "TargetGroupNotFound".
	//
	// The specified target group does not exist.
	ErrCodeTargetGroupNotFoundException = "TargetGroupNotFound"

	// ErrCodeTooManyActionsException for service response error code
	// "TooManyActions".
	//
	// You've reached the limit on the number of actions per rule.
	ErrCodeTooManyActionsException = "TooManyActions"

	// ErrCodeTooManyCertificatesException for service response error code
	// "TooManyCertificates".
	//
	// You've reached the limit on the number of certificates per load balancer.
	ErrCodeTooManyCertificatesException = "TooManyCertificates"

	// ErrCodeTooManyListenersException for service response error code
	// "TooManyListeners".
	//
	// You've reached the limit on the number of listeners per load balancer.
	ErrCodeTooManyListenersException = "TooManyListeners"

	// ErrCodeTooManyLoadBalancersException for service response error code
	// "TooManyLoadBalancers".
	//
	// You've reached the limit on the number of load balancers for your AWS account.
	ErrCodeTooManyLoadBalancersException = "TooManyLoadBalancers"

	// ErrCodeTooManyRegistrationsForTargetIdException for service response error code
	// "TooManyRegistrationsForTargetId".
	//
	// You've reached the limit on the number of times a target can be registered
	// with a load balancer.
	ErrCodeTooManyRegistrationsForTargetIdException = "TooManyRegistrationsForTargetId"

	// ErrCodeTooManyRulesException for service response error code
	// "TooManyRules".
	//
	// You've reached the limit on the number of rules per load balancer.
	ErrCodeTooManyRulesException = "TooManyRules"

	// ErrCodeTooManyTagsException for service response error code
	// "TooManyTags".
	//
	// You've reached the limit on the number of tags per load balancer.
	ErrCodeTooManyTagsException = "TooManyTags"

	// ErrCodeTooManyTargetGroupsException for service response error code
	// "TooManyTargetGroups".
	//
	// You've reached the limit on the number of target groups for your AWS account.
	ErrCodeTooManyTargetGroupsException = "TooManyTargetGroups"

	// ErrCodeTooManyTargetsException for service response error code
	// "TooManyTargets".
	//
	// You've reached the limit on the number of targets.
	ErrCodeTooManyTargetsException = "TooManyTargets"

	// ErrCodeTooManyUniqueTargetGroupsPerLoadBalancerException for service response error code
	// "TooManyUniqueTargetGroupsPerLoadBalancer".
	//
	// You've reached the limit on the number of unique target groups per load balancer
	// across all listeners. If a target group is used by multiple actions for a
	// load balancer, it is counted as only one use.
	ErrCodeTooManyUniqueTargetGroupsPerLoadBalancerException = "TooManyUniqueTargetGroupsPerLoadBalancer"

	// ErrCodeUnsupportedProtocolException for service response error code
	// "UnsupportedProtocol".
	//
	// The specified protocol is not supported.
	ErrCodeUnsupportedProtocolException = "UnsupportedProtocol"
)
View Source
const (
	ServiceName = "elasticloadbalancing"      // Name of service.
	EndpointsID = ServiceName                 // ID to lookup a service endpoint with.
	ServiceID   = "Elastic Load Balancing v2" // ServiceID is a unique identifier of a specific service.
)

    Service information constants

    Variables

    This section is empty.

    Functions

    func ActionTypeEnum_Values

    func ActionTypeEnum_Values() []string

      ActionTypeEnum_Values returns all elements of the ActionTypeEnum enum

      func AuthenticateCognitoActionConditionalBehaviorEnum_Values

      func AuthenticateCognitoActionConditionalBehaviorEnum_Values() []string

        AuthenticateCognitoActionConditionalBehaviorEnum_Values returns all elements of the AuthenticateCognitoActionConditionalBehaviorEnum enum

        func AuthenticateOidcActionConditionalBehaviorEnum_Values

        func AuthenticateOidcActionConditionalBehaviorEnum_Values() []string

          AuthenticateOidcActionConditionalBehaviorEnum_Values returns all elements of the AuthenticateOidcActionConditionalBehaviorEnum enum

          func IpAddressType_Values

          func IpAddressType_Values() []string

            IpAddressType_Values returns all elements of the IpAddressType enum

            func LoadBalancerSchemeEnum_Values

            func LoadBalancerSchemeEnum_Values() []string

              LoadBalancerSchemeEnum_Values returns all elements of the LoadBalancerSchemeEnum enum

              func LoadBalancerStateEnum_Values

              func LoadBalancerStateEnum_Values() []string

                LoadBalancerStateEnum_Values returns all elements of the LoadBalancerStateEnum enum

                func LoadBalancerTypeEnum_Values

                func LoadBalancerTypeEnum_Values() []string

                  LoadBalancerTypeEnum_Values returns all elements of the LoadBalancerTypeEnum enum

                  func ProtocolEnum_Values

                  func ProtocolEnum_Values() []string

                    ProtocolEnum_Values returns all elements of the ProtocolEnum enum

                    func RedirectActionStatusCodeEnum_Values

                    func RedirectActionStatusCodeEnum_Values() []string

                      RedirectActionStatusCodeEnum_Values returns all elements of the RedirectActionStatusCodeEnum enum

                      func TargetHealthReasonEnum_Values

                      func TargetHealthReasonEnum_Values() []string

                        TargetHealthReasonEnum_Values returns all elements of the TargetHealthReasonEnum enum

                        func TargetHealthStateEnum_Values

                        func TargetHealthStateEnum_Values() []string

                          TargetHealthStateEnum_Values returns all elements of the TargetHealthStateEnum enum

                          func TargetTypeEnum_Values

                          func TargetTypeEnum_Values() []string

                            TargetTypeEnum_Values returns all elements of the TargetTypeEnum enum

                            Types

                            type Action

                            type Action struct {
                            
                            	// [HTTPS listeners] Information for using Amazon Cognito to authenticate users.
                            	// Specify only when Type is authenticate-cognito.
                            	AuthenticateCognitoConfig *AuthenticateCognitoActionConfig `type:"structure"`
                            
                            	// [HTTPS listeners] Information about an identity provider that is compliant
                            	// with OpenID Connect (OIDC). Specify only when Type is authenticate-oidc.
                            	AuthenticateOidcConfig *AuthenticateOidcActionConfig `type:"structure"`
                            
                            	// [Application Load Balancer] Information for creating an action that returns
                            	// a custom HTTP response. Specify only when Type is fixed-response.
                            	FixedResponseConfig *FixedResponseActionConfig `type:"structure"`
                            
                            	// Information for creating an action that distributes requests among one or
                            	// more target groups. For Network Load Balancers, you can specify a single
                            	// target group. Specify only when Type is forward. If you specify both ForwardConfig
                            	// and TargetGroupArn, you can specify only one target group using ForwardConfig
                            	// and it must be the same target group specified in TargetGroupArn.
                            	ForwardConfig *ForwardActionConfig `type:"structure"`
                            
                            	// The order for the action. This value is required for rules with multiple
                            	// actions. The action with the lowest value for order is performed first.
                            	Order *int64 `min:"1" type:"integer"`
                            
                            	// [Application Load Balancer] Information for creating a redirect action. Specify
                            	// only when Type is redirect.
                            	RedirectConfig *RedirectActionConfig `type:"structure"`
                            
                            	// The Amazon Resource Name (ARN) of the target group. Specify only when Type
                            	// is forward and you want to route to a single target group. To route to one
                            	// or more target groups, use ForwardConfig instead.
                            	TargetGroupArn *string `type:"string"`
                            
                            	// The type of action.
                            	//
                            	// Type is a required field
                            	Type *string `type:"string" required:"true" enum:"ActionTypeEnum"`
                            	// contains filtered or unexported fields
                            }

                              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.

                              func (Action) GoString

                              func (s Action) GoString() string

                                GoString returns the string representation

                                func (*Action) SetAuthenticateCognitoConfig

                                func (s *Action) SetAuthenticateCognitoConfig(v *AuthenticateCognitoActionConfig) *Action

                                  SetAuthenticateCognitoConfig sets the AuthenticateCognitoConfig field's value.

                                  func (*Action) SetAuthenticateOidcConfig

                                  func (s *Action) SetAuthenticateOidcConfig(v *AuthenticateOidcActionConfig) *Action

                                    SetAuthenticateOidcConfig sets the AuthenticateOidcConfig field's value.

                                    func (*Action) SetFixedResponseConfig

                                    func (s *Action) SetFixedResponseConfig(v *FixedResponseActionConfig) *Action

                                      SetFixedResponseConfig sets the FixedResponseConfig field's value.

                                      func (*Action) SetForwardConfig

                                      func (s *Action) SetForwardConfig(v *ForwardActionConfig) *Action

                                        SetForwardConfig sets the ForwardConfig field's value.

                                        func (*Action) SetOrder

                                        func (s *Action) SetOrder(v int64) *Action

                                          SetOrder sets the Order field's value.

                                          func (*Action) SetRedirectConfig

                                          func (s *Action) SetRedirectConfig(v *RedirectActionConfig) *Action

                                            SetRedirectConfig sets the RedirectConfig field's value.

                                            func (*Action) SetTargetGroupArn

                                            func (s *Action) SetTargetGroupArn(v string) *Action

                                              SetTargetGroupArn sets the TargetGroupArn field's value.

                                              func (*Action) SetType

                                              func (s *Action) SetType(v string) *Action

                                                SetType sets the Type field's value.

                                                func (Action) String

                                                func (s Action) String() string

                                                  String returns the string representation

                                                  func (*Action) Validate

                                                  func (s *Action) Validate() error

                                                    Validate inspects the fields of the type to determine if they are valid.

                                                    type AddListenerCertificatesInput

                                                    type AddListenerCertificatesInput struct {
                                                    
                                                    	// The certificate to add. You can specify one certificate per call. Set CertificateArn
                                                    	// to the certificate ARN but do not set IsDefault.
                                                    	//
                                                    	// Certificates is a required field
                                                    	Certificates []*Certificate `type:"list" required:"true"`
                                                    
                                                    	// The Amazon Resource Name (ARN) of the listener.
                                                    	//
                                                    	// ListenerArn is a required field
                                                    	ListenerArn *string `type:"string" required:"true"`
                                                    	// contains filtered or unexported fields
                                                    }

                                                    func (AddListenerCertificatesInput) GoString

                                                    func (s AddListenerCertificatesInput) GoString() string

                                                      GoString returns the string representation

                                                      func (*AddListenerCertificatesInput) SetCertificates

                                                        SetCertificates sets the Certificates field's value.

                                                        func (*AddListenerCertificatesInput) SetListenerArn

                                                          SetListenerArn sets the ListenerArn field's value.

                                                          func (AddListenerCertificatesInput) String

                                                            String returns the string representation

                                                            func (*AddListenerCertificatesInput) Validate

                                                            func (s *AddListenerCertificatesInput) Validate() error

                                                              Validate inspects the fields of the type to determine if they are valid.

                                                              type AddListenerCertificatesOutput

                                                              type AddListenerCertificatesOutput struct {
                                                              
                                                              	// Information about the certificates in the certificate list.
                                                              	Certificates []*Certificate `type:"list"`
                                                              	// contains filtered or unexported fields
                                                              }

                                                              func (AddListenerCertificatesOutput) GoString

                                                                GoString returns the string representation

                                                                func (*AddListenerCertificatesOutput) SetCertificates

                                                                  SetCertificates sets the Certificates field's value.

                                                                  func (AddListenerCertificatesOutput) String

                                                                    String returns the string representation

                                                                    type AddTagsInput

                                                                    type AddTagsInput struct {
                                                                    
                                                                    	// The Amazon Resource Name (ARN) of the resource.
                                                                    	//
                                                                    	// ResourceArns is a required field
                                                                    	ResourceArns []*string `type:"list" required:"true"`
                                                                    
                                                                    	// The tags.
                                                                    	//
                                                                    	// Tags is a required field
                                                                    	Tags []*Tag `min:"1" type:"list" required:"true"`
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                    func (AddTagsInput) GoString

                                                                    func (s AddTagsInput) GoString() string

                                                                      GoString returns the string representation

                                                                      func (*AddTagsInput) SetResourceArns

                                                                      func (s *AddTagsInput) SetResourceArns(v []*string) *AddTagsInput

                                                                        SetResourceArns sets the ResourceArns field's value.

                                                                        func (*AddTagsInput) SetTags

                                                                        func (s *AddTagsInput) SetTags(v []*Tag) *AddTagsInput

                                                                          SetTags sets the Tags field's value.

                                                                          func (AddTagsInput) String

                                                                          func (s AddTagsInput) String() string

                                                                            String returns the string representation

                                                                            func (*AddTagsInput) Validate

                                                                            func (s *AddTagsInput) Validate() error

                                                                              Validate inspects the fields of the type to determine if they are valid.

                                                                              type AddTagsOutput

                                                                              type AddTagsOutput struct {
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                              func (AddTagsOutput) GoString

                                                                              func (s AddTagsOutput) GoString() string

                                                                                GoString returns the string representation

                                                                                func (AddTagsOutput) String

                                                                                func (s AddTagsOutput) String() string

                                                                                  String returns the string representation

                                                                                  type AuthenticateCognitoActionConfig

                                                                                  type AuthenticateCognitoActionConfig struct {
                                                                                  
                                                                                  	// The query parameters (up to 10) to include in the redirect request to the
                                                                                  	// authorization endpoint.
                                                                                  	AuthenticationRequestExtraParams map[string]*string `type:"map"`
                                                                                  
                                                                                  	// The behavior if the user is not authenticated. The following are possible
                                                                                  	// values:
                                                                                  	//
                                                                                  	//    * deny - Return an HTTP 401 Unauthorized error.
                                                                                  	//
                                                                                  	//    * allow - Allow the request to be forwarded to the target.
                                                                                  	//
                                                                                  	//    * authenticate - Redirect the request to the IdP authorization endpoint.
                                                                                  	//    This is the default value.
                                                                                  	OnUnauthenticatedRequest *string `type:"string" enum:"AuthenticateCognitoActionConditionalBehaviorEnum"`
                                                                                  
                                                                                  	// The set of user claims to be requested from the IdP. The default is openid.
                                                                                  	//
                                                                                  	// To verify which scope values your IdP supports and how to separate multiple
                                                                                  	// values, see the documentation for your IdP.
                                                                                  	Scope *string `type:"string"`
                                                                                  
                                                                                  	// The name of the cookie used to maintain session information. The default
                                                                                  	// is AWSELBAuthSessionCookie.
                                                                                  	SessionCookieName *string `type:"string"`
                                                                                  
                                                                                  	// The maximum duration of the authentication session, in seconds. The default
                                                                                  	// is 604800 seconds (7 days).
                                                                                  	SessionTimeout *int64 `type:"long"`
                                                                                  
                                                                                  	// The Amazon Resource Name (ARN) of the Amazon Cognito user pool.
                                                                                  	//
                                                                                  	// UserPoolArn is a required field
                                                                                  	UserPoolArn *string `type:"string" required:"true"`
                                                                                  
                                                                                  	// The ID of the Amazon Cognito user pool client.
                                                                                  	//
                                                                                  	// UserPoolClientId is a required field
                                                                                  	UserPoolClientId *string `type:"string" required:"true"`
                                                                                  
                                                                                  	// The domain prefix or fully-qualified domain name of the Amazon Cognito user
                                                                                  	// pool.
                                                                                  	//
                                                                                  	// UserPoolDomain is a required field
                                                                                  	UserPoolDomain *string `type:"string" required:"true"`
                                                                                  	// contains filtered or unexported fields
                                                                                  }

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

                                                                                    func (AuthenticateCognitoActionConfig) GoString

                                                                                      GoString returns the string representation

                                                                                      func (*AuthenticateCognitoActionConfig) SetAuthenticationRequestExtraParams

                                                                                      func (s *AuthenticateCognitoActionConfig) SetAuthenticationRequestExtraParams(v map[string]*string) *AuthenticateCognitoActionConfig

                                                                                        SetAuthenticationRequestExtraParams sets the AuthenticationRequestExtraParams field's value.

                                                                                        func (*AuthenticateCognitoActionConfig) SetOnUnauthenticatedRequest

                                                                                        func (s *AuthenticateCognitoActionConfig) SetOnUnauthenticatedRequest(v string) *AuthenticateCognitoActionConfig

                                                                                          SetOnUnauthenticatedRequest sets the OnUnauthenticatedRequest field's value.

                                                                                          func (*AuthenticateCognitoActionConfig) SetScope

                                                                                            SetScope sets the Scope field's value.

                                                                                            func (*AuthenticateCognitoActionConfig) SetSessionCookieName

                                                                                              SetSessionCookieName sets the SessionCookieName field's value.

                                                                                              func (*AuthenticateCognitoActionConfig) SetSessionTimeout

                                                                                                SetSessionTimeout sets the SessionTimeout field's value.

                                                                                                func (*AuthenticateCognitoActionConfig) SetUserPoolArn

                                                                                                  SetUserPoolArn sets the UserPoolArn field's value.

                                                                                                  func (*AuthenticateCognitoActionConfig) SetUserPoolClientId

                                                                                                    SetUserPoolClientId sets the UserPoolClientId field's value.

                                                                                                    func (*AuthenticateCognitoActionConfig) SetUserPoolDomain

                                                                                                      SetUserPoolDomain sets the UserPoolDomain field's value.

                                                                                                      func (AuthenticateCognitoActionConfig) String

                                                                                                        String returns the string representation

                                                                                                        func (*AuthenticateCognitoActionConfig) Validate

                                                                                                        func (s *AuthenticateCognitoActionConfig) Validate() error

                                                                                                          Validate inspects the fields of the type to determine if they are valid.

                                                                                                          type AuthenticateOidcActionConfig

                                                                                                          type AuthenticateOidcActionConfig struct {
                                                                                                          
                                                                                                          	// The query parameters (up to 10) to include in the redirect request to the
                                                                                                          	// authorization endpoint.
                                                                                                          	AuthenticationRequestExtraParams map[string]*string `type:"map"`
                                                                                                          
                                                                                                          	// The authorization endpoint of the IdP. This must be a full URL, including
                                                                                                          	// the HTTPS protocol, the domain, and the path.
                                                                                                          	//
                                                                                                          	// AuthorizationEndpoint is a required field
                                                                                                          	AuthorizationEndpoint *string `type:"string" required:"true"`
                                                                                                          
                                                                                                          	// The OAuth 2.0 client identifier.
                                                                                                          	//
                                                                                                          	// ClientId is a required field
                                                                                                          	ClientId *string `type:"string" required:"true"`
                                                                                                          
                                                                                                          	// The OAuth 2.0 client secret. This parameter is required if you are creating
                                                                                                          	// a rule. If you are modifying a rule, you can omit this parameter if you set
                                                                                                          	// UseExistingClientSecret to true.
                                                                                                          	ClientSecret *string `type:"string"`
                                                                                                          
                                                                                                          	// The OIDC issuer identifier of the IdP. This must be a full URL, including
                                                                                                          	// the HTTPS protocol, the domain, and the path.
                                                                                                          	//
                                                                                                          	// Issuer is a required field
                                                                                                          	Issuer *string `type:"string" required:"true"`
                                                                                                          
                                                                                                          	// The behavior if the user is not authenticated. The following are possible
                                                                                                          	// values:
                                                                                                          	//
                                                                                                          	//    * deny - Return an HTTP 401 Unauthorized error.
                                                                                                          	//
                                                                                                          	//    * allow - Allow the request to be forwarded to the target.
                                                                                                          	//
                                                                                                          	//    * authenticate - Redirect the request to the IdP authorization endpoint.
                                                                                                          	//    This is the default value.
                                                                                                          	OnUnauthenticatedRequest *string `type:"string" enum:"AuthenticateOidcActionConditionalBehaviorEnum"`
                                                                                                          
                                                                                                          	// The set of user claims to be requested from the IdP. The default is openid.
                                                                                                          	//
                                                                                                          	// To verify which scope values your IdP supports and how to separate multiple
                                                                                                          	// values, see the documentation for your IdP.
                                                                                                          	Scope *string `type:"string"`
                                                                                                          
                                                                                                          	// The name of the cookie used to maintain session information. The default
                                                                                                          	// is AWSELBAuthSessionCookie.
                                                                                                          	SessionCookieName *string `type:"string"`
                                                                                                          
                                                                                                          	// The maximum duration of the authentication session, in seconds. The default
                                                                                                          	// is 604800 seconds (7 days).
                                                                                                          	SessionTimeout *int64 `type:"long"`
                                                                                                          
                                                                                                          	// The token endpoint of the IdP. This must be a full URL, including the HTTPS
                                                                                                          	// protocol, the domain, and the path.
                                                                                                          	//
                                                                                                          	// TokenEndpoint is a required field
                                                                                                          	TokenEndpoint *string `type:"string" required:"true"`
                                                                                                          
                                                                                                          	// Indicates whether to use the existing client secret when modifying a rule.
                                                                                                          	// If you are creating a rule, you can omit this parameter or set it to false.
                                                                                                          	UseExistingClientSecret *bool `type:"boolean"`
                                                                                                          
                                                                                                          	// The user info endpoint of the IdP. This must be a full URL, including the
                                                                                                          	// HTTPS protocol, the domain, and the path.
                                                                                                          	//
                                                                                                          	// UserInfoEndpoint is a required field
                                                                                                          	UserInfoEndpoint *string `type:"string" required:"true"`
                                                                                                          	// contains filtered or unexported fields
                                                                                                          }

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

                                                                                                            func (AuthenticateOidcActionConfig) GoString

                                                                                                            func (s AuthenticateOidcActionConfig) GoString() string

                                                                                                              GoString returns the string representation

                                                                                                              func (*AuthenticateOidcActionConfig) SetAuthenticationRequestExtraParams

                                                                                                              func (s *AuthenticateOidcActionConfig) SetAuthenticationRequestExtraParams(v map[string]*string) *AuthenticateOidcActionConfig

                                                                                                                SetAuthenticationRequestExtraParams sets the AuthenticationRequestExtraParams field's value.

                                                                                                                func (*AuthenticateOidcActionConfig) SetAuthorizationEndpoint

                                                                                                                func (s *AuthenticateOidcActionConfig) SetAuthorizationEndpoint(v string) *AuthenticateOidcActionConfig

                                                                                                                  SetAuthorizationEndpoint sets the AuthorizationEndpoint field's value.

                                                                                                                  func (*AuthenticateOidcActionConfig) SetClientId

                                                                                                                    SetClientId sets the ClientId field's value.

                                                                                                                    func (*AuthenticateOidcActionConfig) SetClientSecret

                                                                                                                      SetClientSecret sets the ClientSecret field's value.

                                                                                                                      func (*AuthenticateOidcActionConfig) SetIssuer

                                                                                                                        SetIssuer sets the Issuer field's value.

                                                                                                                        func (*AuthenticateOidcActionConfig) SetOnUnauthenticatedRequest

                                                                                                                        func (s *AuthenticateOidcActionConfig) SetOnUnauthenticatedRequest(v string) *AuthenticateOidcActionConfig

                                                                                                                          SetOnUnauthenticatedRequest sets the OnUnauthenticatedRequest field's value.

                                                                                                                          func (*AuthenticateOidcActionConfig) SetScope

                                                                                                                            SetScope sets the Scope field's value.

                                                                                                                            func (*AuthenticateOidcActionConfig) SetSessionCookieName

                                                                                                                              SetSessionCookieName sets the SessionCookieName field's value.

                                                                                                                              func (*AuthenticateOidcActionConfig) SetSessionTimeout

                                                                                                                                SetSessionTimeout sets the SessionTimeout field's value.

                                                                                                                                func (*AuthenticateOidcActionConfig) SetTokenEndpoint

                                                                                                                                  SetTokenEndpoint sets the TokenEndpoint field's value.

                                                                                                                                  func (*AuthenticateOidcActionConfig) SetUseExistingClientSecret

                                                                                                                                  func (s *AuthenticateOidcActionConfig) SetUseExistingClientSecret(v bool) *AuthenticateOidcActionConfig

                                                                                                                                    SetUseExistingClientSecret sets the UseExistingClientSecret field's value.

                                                                                                                                    func (*AuthenticateOidcActionConfig) SetUserInfoEndpoint

                                                                                                                                      SetUserInfoEndpoint sets the UserInfoEndpoint field's value.

                                                                                                                                      func (AuthenticateOidcActionConfig) String

                                                                                                                                        String returns the string representation

                                                                                                                                        func (*AuthenticateOidcActionConfig) Validate

                                                                                                                                        func (s *AuthenticateOidcActionConfig) Validate() error

                                                                                                                                          Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                          type AvailabilityZone

                                                                                                                                          type AvailabilityZone struct {
                                                                                                                                          
                                                                                                                                          	// [Network Load Balancers] If you need static IP addresses for your load balancer,
                                                                                                                                          	// you can specify one Elastic IP address per Availability Zone when you create
                                                                                                                                          	// an internal-facing load balancer. For internal load balancers, you can specify
                                                                                                                                          	// a private IP address from the IPv4 range of the subnet.
                                                                                                                                          	LoadBalancerAddresses []*LoadBalancerAddress `type:"list"`
                                                                                                                                          
                                                                                                                                          	// [Application Load Balancers on Outposts] The ID of the Outpost.
                                                                                                                                          	OutpostId *string `type:"string"`
                                                                                                                                          
                                                                                                                                          	// The ID of the subnet. You can specify one subnet per Availability Zone.
                                                                                                                                          	SubnetId *string `type:"string"`
                                                                                                                                          
                                                                                                                                          	// The name of the Availability Zone.
                                                                                                                                          	ZoneName *string `type:"string"`
                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                          }

                                                                                                                                            Information about an Availability Zone.

                                                                                                                                            func (AvailabilityZone) GoString

                                                                                                                                            func (s AvailabilityZone) GoString() string

                                                                                                                                              GoString returns the string representation

                                                                                                                                              func (*AvailabilityZone) SetLoadBalancerAddresses

                                                                                                                                              func (s *AvailabilityZone) SetLoadBalancerAddresses(v []*LoadBalancerAddress) *AvailabilityZone

                                                                                                                                                SetLoadBalancerAddresses sets the LoadBalancerAddresses field's value.

                                                                                                                                                func (*AvailabilityZone) SetOutpostId

                                                                                                                                                func (s *AvailabilityZone) SetOutpostId(v string) *AvailabilityZone

                                                                                                                                                  SetOutpostId sets the OutpostId field's value.

                                                                                                                                                  func (*AvailabilityZone) SetSubnetId

                                                                                                                                                  func (s *AvailabilityZone) SetSubnetId(v string) *AvailabilityZone

                                                                                                                                                    SetSubnetId sets the SubnetId field's value.

                                                                                                                                                    func (*AvailabilityZone) SetZoneName

                                                                                                                                                    func (s *AvailabilityZone) SetZoneName(v string) *AvailabilityZone

                                                                                                                                                      SetZoneName sets the ZoneName field's value.

                                                                                                                                                      func (AvailabilityZone) String

                                                                                                                                                      func (s AvailabilityZone) String() string

                                                                                                                                                        String returns the string representation

                                                                                                                                                        type Certificate

                                                                                                                                                        type Certificate struct {
                                                                                                                                                        
                                                                                                                                                        	// The Amazon Resource Name (ARN) of the certificate.
                                                                                                                                                        	CertificateArn *string `type:"string"`
                                                                                                                                                        
                                                                                                                                                        	// Indicates whether the certificate is the default certificate. Do not set
                                                                                                                                                        	// this value when specifying a certificate as an input. This value is not included
                                                                                                                                                        	// in the output when describing a listener, but is included when describing
                                                                                                                                                        	// listener certificates.
                                                                                                                                                        	IsDefault *bool `type:"boolean"`
                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                        }

                                                                                                                                                          Information about an SSL server certificate.

                                                                                                                                                          func (Certificate) GoString

                                                                                                                                                          func (s Certificate) GoString() string

                                                                                                                                                            GoString returns the string representation

                                                                                                                                                            func (*Certificate) SetCertificateArn

                                                                                                                                                            func (s *Certificate) SetCertificateArn(v string) *Certificate

                                                                                                                                                              SetCertificateArn sets the CertificateArn field's value.

                                                                                                                                                              func (*Certificate) SetIsDefault

                                                                                                                                                              func (s *Certificate) SetIsDefault(v bool) *Certificate

                                                                                                                                                                SetIsDefault sets the IsDefault field's value.

                                                                                                                                                                func (Certificate) String

                                                                                                                                                                func (s Certificate) String() string

                                                                                                                                                                  String returns the string representation

                                                                                                                                                                  type Cipher

                                                                                                                                                                  type Cipher struct {
                                                                                                                                                                  
                                                                                                                                                                  	// The name of the cipher.
                                                                                                                                                                  	Name *string `type:"string"`
                                                                                                                                                                  
                                                                                                                                                                  	// The priority of the cipher.
                                                                                                                                                                  	Priority *int64 `type:"integer"`
                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                  }

                                                                                                                                                                    Information about a cipher used in a policy.

                                                                                                                                                                    func (Cipher) GoString

                                                                                                                                                                    func (s Cipher) GoString() string

                                                                                                                                                                      GoString returns the string representation

                                                                                                                                                                      func (*Cipher) SetName

                                                                                                                                                                      func (s *Cipher) SetName(v string) *Cipher

                                                                                                                                                                        SetName sets the Name field's value.

                                                                                                                                                                        func (*Cipher) SetPriority

                                                                                                                                                                        func (s *Cipher) SetPriority(v int64) *Cipher

                                                                                                                                                                          SetPriority sets the Priority field's value.

                                                                                                                                                                          func (Cipher) String

                                                                                                                                                                          func (s Cipher) String() string

                                                                                                                                                                            String returns the string representation

                                                                                                                                                                            type CreateListenerInput

                                                                                                                                                                            type CreateListenerInput struct {
                                                                                                                                                                            
                                                                                                                                                                            	// [TLS listeners] The name of the Application-Layer Protocol Negotiation (ALPN)
                                                                                                                                                                            	// policy. You can specify one policy name. The following are the possible values:
                                                                                                                                                                            	//
                                                                                                                                                                            	//    * HTTP1Only
                                                                                                                                                                            	//
                                                                                                                                                                            	//    * HTTP2Only
                                                                                                                                                                            	//
                                                                                                                                                                            	//    * HTTP2Optional
                                                                                                                                                                            	//
                                                                                                                                                                            	//    * HTTP2Preferred
                                                                                                                                                                            	//
                                                                                                                                                                            	//    * None
                                                                                                                                                                            	//
                                                                                                                                                                            	// For more information, see ALPN policies (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#alpn-policies)
                                                                                                                                                                            	// in the Network Load Balancers Guide.
                                                                                                                                                                            	AlpnPolicy []*string `type:"list"`
                                                                                                                                                                            
                                                                                                                                                                            	// [HTTPS and TLS listeners] The default certificate for the listener. You must
                                                                                                                                                                            	// provide exactly one certificate. Set CertificateArn to the certificate ARN
                                                                                                                                                                            	// but do not set IsDefault.
                                                                                                                                                                            	Certificates []*Certificate `type:"list"`
                                                                                                                                                                            
                                                                                                                                                                            	// The actions for the default rule.
                                                                                                                                                                            	//
                                                                                                                                                                            	// DefaultActions is a required field
                                                                                                                                                                            	DefaultActions []*Action `type:"list" required:"true"`
                                                                                                                                                                            
                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                            	//
                                                                                                                                                                            	// LoadBalancerArn is a required field
                                                                                                                                                                            	LoadBalancerArn *string `type:"string" required:"true"`
                                                                                                                                                                            
                                                                                                                                                                            	// The port on which the load balancer is listening. You cannot specify a port
                                                                                                                                                                            	// for a Gateway Load Balancer.
                                                                                                                                                                            	Port *int64 `min:"1" type:"integer"`
                                                                                                                                                                            
                                                                                                                                                                            	// The protocol for connections from clients to the load balancer. For Application
                                                                                                                                                                            	// Load Balancers, the supported protocols are HTTP and HTTPS. For Network Load
                                                                                                                                                                            	// Balancers, the supported protocols are TCP, TLS, UDP, and TCP_UDP. You can’t
                                                                                                                                                                            	// specify the UDP or TCP_UDP protocol if dual-stack mode is enabled. You cannot
                                                                                                                                                                            	// specify a protocol for a Gateway Load Balancer.
                                                                                                                                                                            	Protocol *string `type:"string" enum:"ProtocolEnum"`
                                                                                                                                                                            
                                                                                                                                                                            	// [HTTPS and TLS listeners] The security policy that defines which protocols
                                                                                                                                                                            	// and ciphers are supported.
                                                                                                                                                                            	//
                                                                                                                                                                            	// For more information, see Security policies (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies)
                                                                                                                                                                            	// in the Application Load Balancers Guide and Security policies (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#describe-ssl-policies)
                                                                                                                                                                            	// in the Network Load Balancers Guide.
                                                                                                                                                                            	SslPolicy *string `type:"string"`
                                                                                                                                                                            
                                                                                                                                                                            	// The tags to assign to the listener.
                                                                                                                                                                            	Tags []*Tag `min:"1" type:"list"`
                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                            }

                                                                                                                                                                            func (CreateListenerInput) GoString

                                                                                                                                                                            func (s CreateListenerInput) GoString() string

                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                              func (*CreateListenerInput) SetAlpnPolicy

                                                                                                                                                                              func (s *CreateListenerInput) SetAlpnPolicy(v []*string) *CreateListenerInput

                                                                                                                                                                                SetAlpnPolicy sets the AlpnPolicy field's value.

                                                                                                                                                                                func (*CreateListenerInput) SetCertificates

                                                                                                                                                                                func (s *CreateListenerInput) SetCertificates(v []*Certificate) *CreateListenerInput

                                                                                                                                                                                  SetCertificates sets the Certificates field's value.

                                                                                                                                                                                  func (*CreateListenerInput) SetDefaultActions

                                                                                                                                                                                  func (s *CreateListenerInput) SetDefaultActions(v []*Action) *CreateListenerInput

                                                                                                                                                                                    SetDefaultActions sets the DefaultActions field's value.

                                                                                                                                                                                    func (*CreateListenerInput) SetLoadBalancerArn

                                                                                                                                                                                    func (s *CreateListenerInput) SetLoadBalancerArn(v string) *CreateListenerInput

                                                                                                                                                                                      SetLoadBalancerArn sets the LoadBalancerArn field's value.

                                                                                                                                                                                      func (*CreateListenerInput) SetPort

                                                                                                                                                                                        SetPort sets the Port field's value.

                                                                                                                                                                                        func (*CreateListenerInput) SetProtocol

                                                                                                                                                                                        func (s *CreateListenerInput) SetProtocol(v string) *CreateListenerInput

                                                                                                                                                                                          SetProtocol sets the Protocol field's value.

                                                                                                                                                                                          func (*CreateListenerInput) SetSslPolicy

                                                                                                                                                                                          func (s *CreateListenerInput) SetSslPolicy(v string) *CreateListenerInput

                                                                                                                                                                                            SetSslPolicy sets the SslPolicy field's value.

                                                                                                                                                                                            func (*CreateListenerInput) SetTags

                                                                                                                                                                                            func (s *CreateListenerInput) SetTags(v []*Tag) *CreateListenerInput

                                                                                                                                                                                              SetTags sets the Tags field's value.

                                                                                                                                                                                              func (CreateListenerInput) String

                                                                                                                                                                                              func (s CreateListenerInput) String() string

                                                                                                                                                                                                String returns the string representation

                                                                                                                                                                                                func (*CreateListenerInput) Validate

                                                                                                                                                                                                func (s *CreateListenerInput) Validate() error

                                                                                                                                                                                                  Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                  type CreateListenerOutput

                                                                                                                                                                                                  type CreateListenerOutput struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// Information about the listener.
                                                                                                                                                                                                  	Listeners []*Listener `type:"list"`
                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                  }

                                                                                                                                                                                                  func (CreateListenerOutput) GoString

                                                                                                                                                                                                  func (s CreateListenerOutput) GoString() string

                                                                                                                                                                                                    GoString returns the string representation

                                                                                                                                                                                                    func (*CreateListenerOutput) SetListeners

                                                                                                                                                                                                    func (s *CreateListenerOutput) SetListeners(v []*Listener) *CreateListenerOutput

                                                                                                                                                                                                      SetListeners sets the Listeners field's value.

                                                                                                                                                                                                      func (CreateListenerOutput) String

                                                                                                                                                                                                      func (s CreateListenerOutput) String() string

                                                                                                                                                                                                        String returns the string representation

                                                                                                                                                                                                        type CreateLoadBalancerInput

                                                                                                                                                                                                        type CreateLoadBalancerInput struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// [Application Load Balancers on Outposts] The ID of the customer-owned address
                                                                                                                                                                                                        	// pool (CoIP pool).
                                                                                                                                                                                                        	CustomerOwnedIpv4Pool *string `type:"string"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The type of IP addresses used by the subnets for your load balancer. The
                                                                                                                                                                                                        	// possible values are ipv4 (for IPv4 addresses) and dualstack (for IPv4 and
                                                                                                                                                                                                        	// IPv6 addresses). Internal load balancers must use ipv4.
                                                                                                                                                                                                        	IpAddressType *string `type:"string" enum:"IpAddressType"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The name of the load balancer.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// This name must be unique per region per account, can have a maximum of 32
                                                                                                                                                                                                        	// characters, must contain only alphanumeric characters or hyphens, must not
                                                                                                                                                                                                        	// begin or end with a hyphen, and must not begin with "internal-".
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// Name is a required field
                                                                                                                                                                                                        	Name *string `type:"string" required:"true"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The nodes of an Internet-facing load balancer have public IP addresses. The
                                                                                                                                                                                                        	// DNS name of an Internet-facing load balancer is publicly resolvable to the
                                                                                                                                                                                                        	// public IP addresses of the nodes. Therefore, Internet-facing load balancers
                                                                                                                                                                                                        	// can route requests from clients over the internet.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// The nodes of an internal load balancer have only private IP addresses. The
                                                                                                                                                                                                        	// DNS name of an internal load balancer is publicly resolvable to the private
                                                                                                                                                                                                        	// IP addresses of the nodes. Therefore, internal load balancers can route requests
                                                                                                                                                                                                        	// only from clients with access to the VPC for the load balancer.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// The default is an Internet-facing load balancer.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// You cannot specify a scheme for a Gateway Load Balancer.
                                                                                                                                                                                                        	Scheme *string `type:"string" enum:"LoadBalancerSchemeEnum"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// [Application Load Balancers] The IDs of the security groups for the load
                                                                                                                                                                                                        	// balancer.
                                                                                                                                                                                                        	SecurityGroups []*string `type:"list"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The IDs of the public subnets. You can specify only one subnet per Availability
                                                                                                                                                                                                        	// Zone. You must specify either subnets or subnet mappings.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Application Load Balancers] You must specify subnets from at least two Availability
                                                                                                                                                                                                        	// Zones. You cannot specify Elastic IP addresses for your subnets.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Application Load Balancers on Outposts] You must specify one Outpost subnet.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Application Load Balancers on Local Zones] You can specify subnets from
                                                                                                                                                                                                        	// one or more Local Zones.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Network Load Balancers] You can specify subnets from one or more Availability
                                                                                                                                                                                                        	// Zones. You can specify one Elastic IP address per subnet if you need static
                                                                                                                                                                                                        	// IP addresses for your internet-facing load balancer. For internal load balancers,
                                                                                                                                                                                                        	// you can specify one private IP address per subnet from the IPv4 range of
                                                                                                                                                                                                        	// the subnet. For internet-facing load balancer, you can specify one IPv6 address
                                                                                                                                                                                                        	// per subnet.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Gateway Load Balancers] You can specify subnets from one or more Availability
                                                                                                                                                                                                        	// Zones. You cannot specify Elastic IP addresses for your subnets.
                                                                                                                                                                                                        	SubnetMappings []*SubnetMapping `type:"list"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The IDs of the public subnets. You can specify only one subnet per Availability
                                                                                                                                                                                                        	// Zone. You must specify either subnets or subnet mappings.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Application Load Balancers] You must specify subnets from at least two Availability
                                                                                                                                                                                                        	// Zones.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Application Load Balancers on Outposts] You must specify one Outpost subnet.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Application Load Balancers on Local Zones] You can specify subnets from
                                                                                                                                                                                                        	// one or more Local Zones.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Network Load Balancers] You can specify subnets from one or more Availability
                                                                                                                                                                                                        	// Zones.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// [Gateway Load Balancers] You can specify subnets from one or more Availability
                                                                                                                                                                                                        	// Zones.
                                                                                                                                                                                                        	Subnets []*string `type:"list"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The tags to assign to the load balancer.
                                                                                                                                                                                                        	Tags []*Tag `min:"1" type:"list"`
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The type of load balancer. The default is application.
                                                                                                                                                                                                        	Type *string `type:"string" enum:"LoadBalancerTypeEnum"`
                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                        }

                                                                                                                                                                                                        func (CreateLoadBalancerInput) GoString

                                                                                                                                                                                                        func (s CreateLoadBalancerInput) GoString() string

                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                          func (*CreateLoadBalancerInput) SetCustomerOwnedIpv4Pool

                                                                                                                                                                                                          func (s *CreateLoadBalancerInput) SetCustomerOwnedIpv4Pool(v string) *CreateLoadBalancerInput

                                                                                                                                                                                                            SetCustomerOwnedIpv4Pool sets the CustomerOwnedIpv4Pool field's value.

                                                                                                                                                                                                            func (*CreateLoadBalancerInput) SetIpAddressType

                                                                                                                                                                                                            func (s *CreateLoadBalancerInput) SetIpAddressType(v string) *CreateLoadBalancerInput

                                                                                                                                                                                                              SetIpAddressType sets the IpAddressType field's value.

                                                                                                                                                                                                              func (*CreateLoadBalancerInput) SetName

                                                                                                                                                                                                                SetName sets the Name field's value.

                                                                                                                                                                                                                func (*CreateLoadBalancerInput) SetScheme

                                                                                                                                                                                                                  SetScheme sets the Scheme field's value.

                                                                                                                                                                                                                  func (*CreateLoadBalancerInput) SetSecurityGroups

                                                                                                                                                                                                                  func (s *CreateLoadBalancerInput) SetSecurityGroups(v []*string) *CreateLoadBalancerInput

                                                                                                                                                                                                                    SetSecurityGroups sets the SecurityGroups field's value.

                                                                                                                                                                                                                    func (*CreateLoadBalancerInput) SetSubnetMappings

                                                                                                                                                                                                                      SetSubnetMappings sets the SubnetMappings field's value.

                                                                                                                                                                                                                      func (*CreateLoadBalancerInput) SetSubnets

                                                                                                                                                                                                                        SetSubnets sets the Subnets field's value.

                                                                                                                                                                                                                        func (*CreateLoadBalancerInput) SetTags

                                                                                                                                                                                                                          SetTags sets the Tags field's value.

                                                                                                                                                                                                                          func (*CreateLoadBalancerInput) SetType

                                                                                                                                                                                                                            SetType sets the Type field's value.

                                                                                                                                                                                                                            func (CreateLoadBalancerInput) String

                                                                                                                                                                                                                            func (s CreateLoadBalancerInput) String() string

                                                                                                                                                                                                                              String returns the string representation

                                                                                                                                                                                                                              func (*CreateLoadBalancerInput) Validate

                                                                                                                                                                                                                              func (s *CreateLoadBalancerInput) Validate() error

                                                                                                                                                                                                                                Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                type CreateLoadBalancerOutput

                                                                                                                                                                                                                                type CreateLoadBalancerOutput struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Information about the load balancer.
                                                                                                                                                                                                                                	LoadBalancers []*LoadBalancer `type:"list"`
                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                func (CreateLoadBalancerOutput) GoString

                                                                                                                                                                                                                                func (s CreateLoadBalancerOutput) GoString() string

                                                                                                                                                                                                                                  GoString returns the string representation

                                                                                                                                                                                                                                  func (*CreateLoadBalancerOutput) SetLoadBalancers

                                                                                                                                                                                                                                    SetLoadBalancers sets the LoadBalancers field's value.

                                                                                                                                                                                                                                    func (CreateLoadBalancerOutput) String

                                                                                                                                                                                                                                    func (s CreateLoadBalancerOutput) String() string

                                                                                                                                                                                                                                      String returns the string representation

                                                                                                                                                                                                                                      type CreateRuleInput

                                                                                                                                                                                                                                      type CreateRuleInput struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The actions.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// Actions is a required field
                                                                                                                                                                                                                                      	Actions []*Action `type:"list" required:"true"`
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The conditions.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// Conditions is a required field
                                                                                                                                                                                                                                      	Conditions []*RuleCondition `type:"list" required:"true"`
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the listener.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// ListenerArn is a required field
                                                                                                                                                                                                                                      	ListenerArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The rule priority. A listener can't have multiple rules with the same priority.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// Priority is a required field
                                                                                                                                                                                                                                      	Priority *int64 `min:"1" type:"integer" required:"true"`
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The tags to assign to the rule.
                                                                                                                                                                                                                                      	Tags []*Tag `min:"1" type:"list"`
                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                      func (CreateRuleInput) GoString

                                                                                                                                                                                                                                      func (s CreateRuleInput) GoString() string

                                                                                                                                                                                                                                        GoString returns the string representation

                                                                                                                                                                                                                                        func (*CreateRuleInput) SetActions

                                                                                                                                                                                                                                        func (s *CreateRuleInput) SetActions(v []*Action) *CreateRuleInput

                                                                                                                                                                                                                                          SetActions sets the Actions field's value.

                                                                                                                                                                                                                                          func (*CreateRuleInput) SetConditions

                                                                                                                                                                                                                                          func (s *CreateRuleInput) SetConditions(v []*RuleCondition) *CreateRuleInput

                                                                                                                                                                                                                                            SetConditions sets the Conditions field's value.

                                                                                                                                                                                                                                            func (*CreateRuleInput) SetListenerArn

                                                                                                                                                                                                                                            func (s *CreateRuleInput) SetListenerArn(v string) *CreateRuleInput

                                                                                                                                                                                                                                              SetListenerArn sets the ListenerArn field's value.

                                                                                                                                                                                                                                              func (*CreateRuleInput) SetPriority

                                                                                                                                                                                                                                              func (s *CreateRuleInput) SetPriority(v int64) *CreateRuleInput

                                                                                                                                                                                                                                                SetPriority sets the Priority field's value.

                                                                                                                                                                                                                                                func (*CreateRuleInput) SetTags

                                                                                                                                                                                                                                                func (s *CreateRuleInput) SetTags(v []*Tag) *CreateRuleInput

                                                                                                                                                                                                                                                  SetTags sets the Tags field's value.

                                                                                                                                                                                                                                                  func (CreateRuleInput) String

                                                                                                                                                                                                                                                  func (s CreateRuleInput) String() string

                                                                                                                                                                                                                                                    String returns the string representation

                                                                                                                                                                                                                                                    func (*CreateRuleInput) Validate

                                                                                                                                                                                                                                                    func (s *CreateRuleInput) Validate() error

                                                                                                                                                                                                                                                      Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                      type CreateRuleOutput

                                                                                                                                                                                                                                                      type CreateRuleOutput struct {
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Information about the rule.
                                                                                                                                                                                                                                                      	Rules []*Rule `type:"list"`
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                      func (CreateRuleOutput) GoString

                                                                                                                                                                                                                                                      func (s CreateRuleOutput) GoString() string

                                                                                                                                                                                                                                                        GoString returns the string representation

                                                                                                                                                                                                                                                        func (*CreateRuleOutput) SetRules

                                                                                                                                                                                                                                                        func (s *CreateRuleOutput) SetRules(v []*Rule) *CreateRuleOutput

                                                                                                                                                                                                                                                          SetRules sets the Rules field's value.

                                                                                                                                                                                                                                                          func (CreateRuleOutput) String

                                                                                                                                                                                                                                                          func (s CreateRuleOutput) String() string

                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                            type CreateTargetGroupInput

                                                                                                                                                                                                                                                            type CreateTargetGroupInput struct {
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// Indicates whether health checks are enabled. If the target type is lambda,
                                                                                                                                                                                                                                                            	// health checks are disabled by default but can be enabled. If the target type
                                                                                                                                                                                                                                                            	// is instance or ip, health checks are always enabled and cannot be disabled.
                                                                                                                                                                                                                                                            	HealthCheckEnabled *bool `type:"boolean"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The approximate amount of time, in seconds, between health checks of an individual
                                                                                                                                                                                                                                                            	// target. If the target group protocol is TCP, TLS, UDP, or TCP_UDP, the supported
                                                                                                                                                                                                                                                            	// values are 10 and 30 seconds. If the target group protocol is HTTP or HTTPS,
                                                                                                                                                                                                                                                            	// the default is 30 seconds. If the target group protocol is GENEVE, the default
                                                                                                                                                                                                                                                            	// is 10 seconds. If the target type is lambda, the default is 35 seconds.
                                                                                                                                                                                                                                                            	HealthCheckIntervalSeconds *int64 `min:"5" type:"integer"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// [HTTP/HTTPS health checks] The destination for health checks on the targets.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// [HTTP1 or HTTP2 protocol version] The ping path. The default is /.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// [GRPC protocol version] The path of a custom health check method with the
                                                                                                                                                                                                                                                            	// format /package.service/method. The default is /AWS.ALB/healthcheck.
                                                                                                                                                                                                                                                            	HealthCheckPath *string `min:"1" type:"string"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The port the load balancer uses when performing health checks on targets.
                                                                                                                                                                                                                                                            	// If the protocol is HTTP, HTTPS, TCP, TLS, UDP, or TCP_UDP, the default is
                                                                                                                                                                                                                                                            	// traffic-port, which is the port on which each target receives traffic from
                                                                                                                                                                                                                                                            	// the load balancer. If the protocol is GENEVE, the default is port 80.
                                                                                                                                                                                                                                                            	HealthCheckPort *string `type:"string"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The protocol the load balancer uses when performing health checks on targets.
                                                                                                                                                                                                                                                            	// For Application Load Balancers, the default is HTTP. For Network Load Balancers
                                                                                                                                                                                                                                                            	// and Gateway Load Balancers, the default is TCP. The TCP protocol is not supported
                                                                                                                                                                                                                                                            	// for health checks if the protocol of the target group is HTTP or HTTPS. The
                                                                                                                                                                                                                                                            	// GENEVE, TLS, UDP, and TCP_UDP protocols are not supported for health checks.
                                                                                                                                                                                                                                                            	HealthCheckProtocol *string `type:"string" enum:"ProtocolEnum"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The amount of time, in seconds, during which no response from a target means
                                                                                                                                                                                                                                                            	// a failed health check. For target groups with a protocol of HTTP, HTTPS,
                                                                                                                                                                                                                                                            	// or GENEVE, the default is 5 seconds. For target groups with a protocol of
                                                                                                                                                                                                                                                            	// TCP or TLS, this value must be 6 seconds for HTTP health checks and 10 seconds
                                                                                                                                                                                                                                                            	// for TCP and HTTPS health checks. If the target type is lambda, the default
                                                                                                                                                                                                                                                            	// is 30 seconds.
                                                                                                                                                                                                                                                            	HealthCheckTimeoutSeconds *int64 `min:"2" type:"integer"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The number of consecutive health checks successes required before considering
                                                                                                                                                                                                                                                            	// an unhealthy target healthy. For target groups with a protocol of HTTP or
                                                                                                                                                                                                                                                            	// HTTPS, the default is 5. For target groups with a protocol of TCP, TLS, or
                                                                                                                                                                                                                                                            	// GENEVE, the default is 3. If the target type is lambda, the default is 5.
                                                                                                                                                                                                                                                            	HealthyThresholdCount *int64 `min:"2" type:"integer"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// [HTTP/HTTPS health checks] The HTTP or gRPC codes to use when checking for
                                                                                                                                                                                                                                                            	// a successful response from a target.
                                                                                                                                                                                                                                                            	Matcher *Matcher `type:"structure"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The name of the target group.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// This name must be unique per region per account, can have a maximum of 32
                                                                                                                                                                                                                                                            	// characters, must contain only alphanumeric characters or hyphens, and must
                                                                                                                                                                                                                                                            	// not begin or end with a hyphen.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	// Name is a required field
                                                                                                                                                                                                                                                            	Name *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The port on which the targets receive traffic. This port is used unless you
                                                                                                                                                                                                                                                            	// specify a port override when registering the target. If the target is a Lambda
                                                                                                                                                                                                                                                            	// function, this parameter does not apply. If the protocol is GENEVE, the supported
                                                                                                                                                                                                                                                            	// port is 6081.
                                                                                                                                                                                                                                                            	Port *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The protocol to use for routing traffic to the targets. For Application Load
                                                                                                                                                                                                                                                            	// Balancers, the supported protocols are HTTP and HTTPS. For Network Load Balancers,
                                                                                                                                                                                                                                                            	// the supported protocols are TCP, TLS, UDP, or TCP_UDP. For Gateway Load Balancers,
                                                                                                                                                                                                                                                            	// the supported protocol is GENEVE. A TCP_UDP listener must be associated with
                                                                                                                                                                                                                                                            	// a TCP_UDP target group. If the target is a Lambda function, this parameter
                                                                                                                                                                                                                                                            	// does not apply.
                                                                                                                                                                                                                                                            	Protocol *string `type:"string" enum:"ProtocolEnum"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// [HTTP/HTTPS protocol] The protocol version. Specify GRPC to send requests
                                                                                                                                                                                                                                                            	// to targets using gRPC. Specify HTTP2 to send requests to targets using HTTP/2.
                                                                                                                                                                                                                                                            	// The default is HTTP1, which sends requests to targets using HTTP/1.1.
                                                                                                                                                                                                                                                            	ProtocolVersion *string `type:"string"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The tags to assign to the target group.
                                                                                                                                                                                                                                                            	Tags []*Tag `min:"1" type:"list"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The type of target that you must specify when registering targets with this
                                                                                                                                                                                                                                                            	// target group. You can't specify targets for a target group using more than
                                                                                                                                                                                                                                                            	// one target type.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	//    * instance - Register targets by instance ID. This is the default value.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	//    * ip - Register targets by IP address. You can specify IP addresses from
                                                                                                                                                                                                                                                            	//    the subnets of the virtual private cloud (VPC) for the target group, the
                                                                                                                                                                                                                                                            	//    RFC 1918 range (10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16), and the
                                                                                                                                                                                                                                                            	//    RFC 6598 range (100.64.0.0/10). You can't specify publicly routable IP
                                                                                                                                                                                                                                                            	//    addresses.
                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                            	//    * lambda - Register a single Lambda function as a target.
                                                                                                                                                                                                                                                            	TargetType *string `type:"string" enum:"TargetTypeEnum"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The number of consecutive health check failures required before considering
                                                                                                                                                                                                                                                            	// a target unhealthy. If the target group protocol is HTTP or HTTPS, the default
                                                                                                                                                                                                                                                            	// is 2. If the target group protocol is TCP or TLS, this value must be the
                                                                                                                                                                                                                                                            	// same as the healthy threshold count. If the target group protocol is GENEVE,
                                                                                                                                                                                                                                                            	// the default is 3. If the target type is lambda, the default is 2.
                                                                                                                                                                                                                                                            	UnhealthyThresholdCount *int64 `min:"2" type:"integer"`
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                            	// The identifier of the virtual private cloud (VPC). If the target is a Lambda
                                                                                                                                                                                                                                                            	// function, this parameter does not apply. Otherwise, this parameter is required.
                                                                                                                                                                                                                                                            	VpcId *string `type:"string"`
                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                            func (CreateTargetGroupInput) GoString

                                                                                                                                                                                                                                                            func (s CreateTargetGroupInput) GoString() string

                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                              func (*CreateTargetGroupInput) SetHealthCheckEnabled

                                                                                                                                                                                                                                                              func (s *CreateTargetGroupInput) SetHealthCheckEnabled(v bool) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                SetHealthCheckEnabled sets the HealthCheckEnabled field's value.

                                                                                                                                                                                                                                                                func (*CreateTargetGroupInput) SetHealthCheckIntervalSeconds

                                                                                                                                                                                                                                                                func (s *CreateTargetGroupInput) SetHealthCheckIntervalSeconds(v int64) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                  SetHealthCheckIntervalSeconds sets the HealthCheckIntervalSeconds field's value.

                                                                                                                                                                                                                                                                  func (*CreateTargetGroupInput) SetHealthCheckPath

                                                                                                                                                                                                                                                                  func (s *CreateTargetGroupInput) SetHealthCheckPath(v string) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                    SetHealthCheckPath sets the HealthCheckPath field's value.

                                                                                                                                                                                                                                                                    func (*CreateTargetGroupInput) SetHealthCheckPort

                                                                                                                                                                                                                                                                    func (s *CreateTargetGroupInput) SetHealthCheckPort(v string) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                      SetHealthCheckPort sets the HealthCheckPort field's value.

                                                                                                                                                                                                                                                                      func (*CreateTargetGroupInput) SetHealthCheckProtocol

                                                                                                                                                                                                                                                                      func (s *CreateTargetGroupInput) SetHealthCheckProtocol(v string) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                        SetHealthCheckProtocol sets the HealthCheckProtocol field's value.

                                                                                                                                                                                                                                                                        func (*CreateTargetGroupInput) SetHealthCheckTimeoutSeconds

                                                                                                                                                                                                                                                                        func (s *CreateTargetGroupInput) SetHealthCheckTimeoutSeconds(v int64) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                          SetHealthCheckTimeoutSeconds sets the HealthCheckTimeoutSeconds field's value.

                                                                                                                                                                                                                                                                          func (*CreateTargetGroupInput) SetHealthyThresholdCount

                                                                                                                                                                                                                                                                          func (s *CreateTargetGroupInput) SetHealthyThresholdCount(v int64) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                            SetHealthyThresholdCount sets the HealthyThresholdCount field's value.

                                                                                                                                                                                                                                                                            func (*CreateTargetGroupInput) SetMatcher

                                                                                                                                                                                                                                                                              SetMatcher sets the Matcher field's value.

                                                                                                                                                                                                                                                                              func (*CreateTargetGroupInput) SetName

                                                                                                                                                                                                                                                                                SetName sets the Name field's value.

                                                                                                                                                                                                                                                                                func (*CreateTargetGroupInput) SetPort

                                                                                                                                                                                                                                                                                  SetPort sets the Port field's value.

                                                                                                                                                                                                                                                                                  func (*CreateTargetGroupInput) SetProtocol

                                                                                                                                                                                                                                                                                    SetProtocol sets the Protocol field's value.

                                                                                                                                                                                                                                                                                    func (*CreateTargetGroupInput) SetProtocolVersion

                                                                                                                                                                                                                                                                                    func (s *CreateTargetGroupInput) SetProtocolVersion(v string) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                                      SetProtocolVersion sets the ProtocolVersion field's value.

                                                                                                                                                                                                                                                                                      func (*CreateTargetGroupInput) SetTags

                                                                                                                                                                                                                                                                                        SetTags sets the Tags field's value.

                                                                                                                                                                                                                                                                                        func (*CreateTargetGroupInput) SetTargetType

                                                                                                                                                                                                                                                                                          SetTargetType sets the TargetType field's value.

                                                                                                                                                                                                                                                                                          func (*CreateTargetGroupInput) SetUnhealthyThresholdCount

                                                                                                                                                                                                                                                                                          func (s *CreateTargetGroupInput) SetUnhealthyThresholdCount(v int64) *CreateTargetGroupInput

                                                                                                                                                                                                                                                                                            SetUnhealthyThresholdCount sets the UnhealthyThresholdCount field's value.

                                                                                                                                                                                                                                                                                            func (*CreateTargetGroupInput) SetVpcId

                                                                                                                                                                                                                                                                                              SetVpcId sets the VpcId field's value.

                                                                                                                                                                                                                                                                                              func (CreateTargetGroupInput) String

                                                                                                                                                                                                                                                                                              func (s CreateTargetGroupInput) String() string

                                                                                                                                                                                                                                                                                                String returns the string representation

                                                                                                                                                                                                                                                                                                func (*CreateTargetGroupInput) Validate

                                                                                                                                                                                                                                                                                                func (s *CreateTargetGroupInput) Validate() error

                                                                                                                                                                                                                                                                                                  Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                  type CreateTargetGroupOutput

                                                                                                                                                                                                                                                                                                  type CreateTargetGroupOutput struct {
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// Information about the target group.
                                                                                                                                                                                                                                                                                                  	TargetGroups []*TargetGroup `type:"list"`
                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                  func (CreateTargetGroupOutput) GoString

                                                                                                                                                                                                                                                                                                  func (s CreateTargetGroupOutput) GoString() string

                                                                                                                                                                                                                                                                                                    GoString returns the string representation

                                                                                                                                                                                                                                                                                                    func (*CreateTargetGroupOutput) SetTargetGroups

                                                                                                                                                                                                                                                                                                      SetTargetGroups sets the TargetGroups field's value.

                                                                                                                                                                                                                                                                                                      func (CreateTargetGroupOutput) String

                                                                                                                                                                                                                                                                                                      func (s CreateTargetGroupOutput) String() string

                                                                                                                                                                                                                                                                                                        String returns the string representation

                                                                                                                                                                                                                                                                                                        type DeleteListenerInput

                                                                                                                                                                                                                                                                                                        type DeleteListenerInput struct {
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the listener.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// ListenerArn is a required field
                                                                                                                                                                                                                                                                                                        	ListenerArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                        func (DeleteListenerInput) GoString

                                                                                                                                                                                                                                                                                                        func (s DeleteListenerInput) GoString() string

                                                                                                                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                                                                                                                          func (*DeleteListenerInput) SetListenerArn

                                                                                                                                                                                                                                                                                                          func (s *DeleteListenerInput) SetListenerArn(v string) *DeleteListenerInput

                                                                                                                                                                                                                                                                                                            SetListenerArn sets the ListenerArn field's value.

                                                                                                                                                                                                                                                                                                            func (DeleteListenerInput) String

                                                                                                                                                                                                                                                                                                            func (s DeleteListenerInput) String() string

                                                                                                                                                                                                                                                                                                              String returns the string representation

                                                                                                                                                                                                                                                                                                              func (*DeleteListenerInput) Validate

                                                                                                                                                                                                                                                                                                              func (s *DeleteListenerInput) Validate() error

                                                                                                                                                                                                                                                                                                                Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                type DeleteListenerOutput

                                                                                                                                                                                                                                                                                                                type DeleteListenerOutput struct {
                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                func (DeleteListenerOutput) GoString

                                                                                                                                                                                                                                                                                                                func (s DeleteListenerOutput) GoString() string

                                                                                                                                                                                                                                                                                                                  GoString returns the string representation

                                                                                                                                                                                                                                                                                                                  func (DeleteListenerOutput) String

                                                                                                                                                                                                                                                                                                                  func (s DeleteListenerOutput) String() string

                                                                                                                                                                                                                                                                                                                    String returns the string representation

                                                                                                                                                                                                                                                                                                                    type DeleteLoadBalancerInput

                                                                                                                                                                                                                                                                                                                    type DeleteLoadBalancerInput struct {
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                    	// LoadBalancerArn is a required field
                                                                                                                                                                                                                                                                                                                    	LoadBalancerArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                    func (DeleteLoadBalancerInput) GoString

                                                                                                                                                                                                                                                                                                                    func (s DeleteLoadBalancerInput) GoString() string

                                                                                                                                                                                                                                                                                                                      GoString returns the string representation

                                                                                                                                                                                                                                                                                                                      func (*DeleteLoadBalancerInput) SetLoadBalancerArn

                                                                                                                                                                                                                                                                                                                      func (s *DeleteLoadBalancerInput) SetLoadBalancerArn(v string) *DeleteLoadBalancerInput

                                                                                                                                                                                                                                                                                                                        SetLoadBalancerArn sets the LoadBalancerArn field's value.

                                                                                                                                                                                                                                                                                                                        func (DeleteLoadBalancerInput) String

                                                                                                                                                                                                                                                                                                                        func (s DeleteLoadBalancerInput) String() string

                                                                                                                                                                                                                                                                                                                          String returns the string representation

                                                                                                                                                                                                                                                                                                                          func (*DeleteLoadBalancerInput) Validate

                                                                                                                                                                                                                                                                                                                          func (s *DeleteLoadBalancerInput) Validate() error

                                                                                                                                                                                                                                                                                                                            Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                            type DeleteLoadBalancerOutput

                                                                                                                                                                                                                                                                                                                            type DeleteLoadBalancerOutput struct {
                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                            func (DeleteLoadBalancerOutput) GoString

                                                                                                                                                                                                                                                                                                                            func (s DeleteLoadBalancerOutput) GoString() string

                                                                                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                                                                                              func (DeleteLoadBalancerOutput) String

                                                                                                                                                                                                                                                                                                                              func (s DeleteLoadBalancerOutput) String() string

                                                                                                                                                                                                                                                                                                                                String returns the string representation

                                                                                                                                                                                                                                                                                                                                type DeleteRuleInput

                                                                                                                                                                                                                                                                                                                                type DeleteRuleInput struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Name (ARN) of the rule.
                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                	// RuleArn is a required field
                                                                                                                                                                                                                                                                                                                                	RuleArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                func (DeleteRuleInput) GoString

                                                                                                                                                                                                                                                                                                                                func (s DeleteRuleInput) GoString() string

                                                                                                                                                                                                                                                                                                                                  GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                  func (*DeleteRuleInput) SetRuleArn

                                                                                                                                                                                                                                                                                                                                  func (s *DeleteRuleInput) SetRuleArn(v string) *DeleteRuleInput

                                                                                                                                                                                                                                                                                                                                    SetRuleArn sets the RuleArn field's value.

                                                                                                                                                                                                                                                                                                                                    func (DeleteRuleInput) String

                                                                                                                                                                                                                                                                                                                                    func (s DeleteRuleInput) String() string

                                                                                                                                                                                                                                                                                                                                      String returns the string representation

                                                                                                                                                                                                                                                                                                                                      func (*DeleteRuleInput) Validate

                                                                                                                                                                                                                                                                                                                                      func (s *DeleteRuleInput) Validate() error

                                                                                                                                                                                                                                                                                                                                        Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                        type DeleteRuleOutput

                                                                                                                                                                                                                                                                                                                                        type DeleteRuleOutput struct {
                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                        func (DeleteRuleOutput) GoString

                                                                                                                                                                                                                                                                                                                                        func (s DeleteRuleOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                          func (DeleteRuleOutput) String

                                                                                                                                                                                                                                                                                                                                          func (s DeleteRuleOutput) String() string

                                                                                                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                                                                                                            type DeleteTargetGroupInput

                                                                                                                                                                                                                                                                                                                                            type DeleteTargetGroupInput struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the target group.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// TargetGroupArn is a required field
                                                                                                                                                                                                                                                                                                                                            	TargetGroupArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                            func (DeleteTargetGroupInput) GoString

                                                                                                                                                                                                                                                                                                                                            func (s DeleteTargetGroupInput) GoString() string

                                                                                                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                              func (*DeleteTargetGroupInput) SetTargetGroupArn

                                                                                                                                                                                                                                                                                                                                              func (s *DeleteTargetGroupInput) SetTargetGroupArn(v string) *DeleteTargetGroupInput

                                                                                                                                                                                                                                                                                                                                                SetTargetGroupArn sets the TargetGroupArn field's value.

                                                                                                                                                                                                                                                                                                                                                func (DeleteTargetGroupInput) String

                                                                                                                                                                                                                                                                                                                                                func (s DeleteTargetGroupInput) String() string

                                                                                                                                                                                                                                                                                                                                                  String returns the string representation

                                                                                                                                                                                                                                                                                                                                                  func (*DeleteTargetGroupInput) Validate

                                                                                                                                                                                                                                                                                                                                                  func (s *DeleteTargetGroupInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                    Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                    type DeleteTargetGroupOutput

                                                                                                                                                                                                                                                                                                                                                    type DeleteTargetGroupOutput struct {
                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                    func (DeleteTargetGroupOutput) GoString

                                                                                                                                                                                                                                                                                                                                                    func (s DeleteTargetGroupOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                      GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                      func (DeleteTargetGroupOutput) String

                                                                                                                                                                                                                                                                                                                                                      func (s DeleteTargetGroupOutput) String() string

                                                                                                                                                                                                                                                                                                                                                        String returns the string representation

                                                                                                                                                                                                                                                                                                                                                        type DeregisterTargetsInput

                                                                                                                                                                                                                                                                                                                                                        type DeregisterTargetsInput struct {
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the target group.
                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                        	// TargetGroupArn is a required field
                                                                                                                                                                                                                                                                                                                                                        	TargetGroupArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// The targets. If you specified a port override when you registered a target,
                                                                                                                                                                                                                                                                                                                                                        	// you must specify both the target ID and the port when you deregister it.
                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                        	// Targets is a required field
                                                                                                                                                                                                                                                                                                                                                        	Targets []*TargetDescription `type:"list" required:"true"`
                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                        func (DeregisterTargetsInput) GoString

                                                                                                                                                                                                                                                                                                                                                        func (s DeregisterTargetsInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                          func (*DeregisterTargetsInput) SetTargetGroupArn

                                                                                                                                                                                                                                                                                                                                                          func (s *DeregisterTargetsInput) SetTargetGroupArn(v string) *DeregisterTargetsInput

                                                                                                                                                                                                                                                                                                                                                            SetTargetGroupArn sets the TargetGroupArn field's value.

                                                                                                                                                                                                                                                                                                                                                            func (*DeregisterTargetsInput) SetTargets

                                                                                                                                                                                                                                                                                                                                                              SetTargets sets the Targets field's value.

                                                                                                                                                                                                                                                                                                                                                              func (DeregisterTargetsInput) String

                                                                                                                                                                                                                                                                                                                                                              func (s DeregisterTargetsInput) String() string

                                                                                                                                                                                                                                                                                                                                                                String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                func (*DeregisterTargetsInput) Validate

                                                                                                                                                                                                                                                                                                                                                                func (s *DeregisterTargetsInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                  Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                  type DeregisterTargetsOutput

                                                                                                                                                                                                                                                                                                                                                                  type DeregisterTargetsOutput struct {
                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                  func (DeregisterTargetsOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                  func (s DeregisterTargetsOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                    GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                    func (DeregisterTargetsOutput) String

                                                                                                                                                                                                                                                                                                                                                                    func (s DeregisterTargetsOutput) String() string

                                                                                                                                                                                                                                                                                                                                                                      String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                      type DescribeAccountLimitsInput

                                                                                                                                                                                                                                                                                                                                                                      type DescribeAccountLimitsInput struct {
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                      	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                      	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                      	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                      	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                      func (DescribeAccountLimitsInput) GoString

                                                                                                                                                                                                                                                                                                                                                                      func (s DescribeAccountLimitsInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                        GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeAccountLimitsInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                          SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                          func (*DescribeAccountLimitsInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                            SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                            func (DescribeAccountLimitsInput) String

                                                                                                                                                                                                                                                                                                                                                                              String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeAccountLimitsInput) Validate

                                                                                                                                                                                                                                                                                                                                                                              func (s *DescribeAccountLimitsInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                type DescribeAccountLimitsOutput

                                                                                                                                                                                                                                                                                                                                                                                type DescribeAccountLimitsOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// Information about the limits.
                                                                                                                                                                                                                                                                                                                                                                                	Limits []*Limit `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                func (DescribeAccountLimitsOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                func (s DescribeAccountLimitsOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                  GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeAccountLimitsOutput) SetLimits

                                                                                                                                                                                                                                                                                                                                                                                    SetLimits sets the Limits field's value.

                                                                                                                                                                                                                                                                                                                                                                                    func (*DescribeAccountLimitsOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                      SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                      func (DescribeAccountLimitsOutput) String

                                                                                                                                                                                                                                                                                                                                                                                        String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                        type DescribeListenerCertificatesInput

                                                                                                                                                                                                                                                                                                                                                                                        type DescribeListenerCertificatesInput struct {
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The Amazon Resource Names (ARN) of the listener.
                                                                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                                                                        	// ListenerArn is a required field
                                                                                                                                                                                                                                                                                                                                                                                        	ListenerArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                                        	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                                        	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                        	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                                        	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                        func (DescribeListenerCertificatesInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                          func (*DescribeListenerCertificatesInput) SetListenerArn

                                                                                                                                                                                                                                                                                                                                                                                            SetListenerArn sets the ListenerArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeListenerCertificatesInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                                              SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeListenerCertificatesInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                                                SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                                                func (DescribeListenerCertificatesInput) String

                                                                                                                                                                                                                                                                                                                                                                                                  String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeListenerCertificatesInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                    Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeListenerCertificatesOutput

                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeListenerCertificatesOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the certificates.
                                                                                                                                                                                                                                                                                                                                                                                                    	Certificates []*Certificate `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                                    	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                                    	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                    func (DescribeListenerCertificatesOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                      GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeListenerCertificatesOutput) SetCertificates

                                                                                                                                                                                                                                                                                                                                                                                                        SetCertificates sets the Certificates field's value.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeListenerCertificatesOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                                          SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeListenerCertificatesOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeListenersInput

                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeListenersInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Names (ARN) of the listeners.
                                                                                                                                                                                                                                                                                                                                                                                                            	ListenerArns []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                            	LoadBalancerArn *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                                                            	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                                                            	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                            	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                                                            	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                            func (DescribeListenersInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                            func (s DescribeListenersInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeListenersInput) SetListenerArns

                                                                                                                                                                                                                                                                                                                                                                                                              func (s *DescribeListenersInput) SetListenerArns(v []*string) *DescribeListenersInput

                                                                                                                                                                                                                                                                                                                                                                                                                SetListenerArns sets the ListenerArns field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeListenersInput) SetLoadBalancerArn

                                                                                                                                                                                                                                                                                                                                                                                                                func (s *DescribeListenersInput) SetLoadBalancerArn(v string) *DescribeListenersInput

                                                                                                                                                                                                                                                                                                                                                                                                                  SetLoadBalancerArn sets the LoadBalancerArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeListenersInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                                                                    SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*DescribeListenersInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                                                                      SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (DescribeListenersInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                      func (s DescribeListenersInput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                        String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeListenersInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *DescribeListenersInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                          Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                          type DescribeListenersOutput

                                                                                                                                                                                                                                                                                                                                                                                                                          type DescribeListenersOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// Information about the listeners.
                                                                                                                                                                                                                                                                                                                                                                                                                          	Listeners []*Listener `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                          	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                                                          	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                                                          	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeListenersOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                          func (s DescribeListenersOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                            GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeListenersOutput) SetListeners

                                                                                                                                                                                                                                                                                                                                                                                                                              SetListeners sets the Listeners field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeListenersOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (DescribeListenersOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                func (s DescribeListenersOutput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                  String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                  type DescribeLoadBalancerAttributesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                  type DescribeLoadBalancerAttributesInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// LoadBalancerArn is a required field
                                                                                                                                                                                                                                                                                                                                                                                                                                  	LoadBalancerArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DescribeLoadBalancerAttributesInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                    GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*DescribeLoadBalancerAttributesInput) SetLoadBalancerArn

                                                                                                                                                                                                                                                                                                                                                                                                                                      SetLoadBalancerArn sets the LoadBalancerArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (DescribeLoadBalancerAttributesInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                        String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeLoadBalancerAttributesInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                          Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                          type DescribeLoadBalancerAttributesOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                          type DescribeLoadBalancerAttributesOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Information about the load balancer attributes.
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Attributes []*LoadBalancerAttribute `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeLoadBalancerAttributesOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                            GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeLoadBalancerAttributesOutput) SetAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                              SetAttributes sets the Attributes field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (DescribeLoadBalancerAttributesOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeLoadBalancersInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeLoadBalancersInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Names (ARN) of the load balancers. You can specify up
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// to 20 load balancers in a single call.
                                                                                                                                                                                                                                                                                                                                                                                                                                                	LoadBalancerArns []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The names of the load balancers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Names []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                                                                                                	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (DescribeLoadBalancersInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s DescribeLoadBalancersInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                  GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeLoadBalancersInput) SetLoadBalancerArns

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *DescribeLoadBalancersInput) SetLoadBalancerArns(v []*string) *DescribeLoadBalancersInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetLoadBalancerArns sets the LoadBalancerArns field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*DescribeLoadBalancersInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeLoadBalancersInput) SetNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetNames sets the Names field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeLoadBalancersInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeLoadBalancersInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeLoadBalancersInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *DescribeLoadBalancersInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                              Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeLoadBalancersOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeLoadBalancersOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Information about the load balancers.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	LoadBalancers []*LoadBalancer `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (DescribeLoadBalancersOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s DescribeLoadBalancersOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeLoadBalancersOutput) SetLoadBalancers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetLoadBalancers sets the LoadBalancers field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeLoadBalancersOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (DescribeLoadBalancersOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DescribeRulesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DescribeRulesInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Name (ARN) of the listener.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ListenerArn *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Resource Names (ARN) of the rules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RuleArns []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (DescribeRulesInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s DescribeRulesInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeRulesInput) SetListenerArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *DescribeRulesInput) SetListenerArn(v string) *DescribeRulesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetListenerArn sets the ListenerArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*DescribeRulesInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *DescribeRulesInput) SetMarker(v string) *DescribeRulesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeRulesInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *DescribeRulesInput) SetPageSize(v int64) *DescribeRulesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeRulesInput) SetRuleArns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *DescribeRulesInput) SetRuleArns(v []*string) *DescribeRulesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetRuleArns sets the RuleArns field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (DescribeRulesInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s DescribeRulesInput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeRulesInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *DescribeRulesInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeRulesOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeRulesOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// Information about the rules.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Rules []*Rule `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (DescribeRulesOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s DescribeRulesOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeRulesOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *DescribeRulesOutput) SetNextMarker(v string) *DescribeRulesOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeRulesOutput) SetRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *DescribeRulesOutput) SetRules(v []*Rule) *DescribeRulesOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetRules sets the Rules field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeRulesOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s DescribeRulesOutput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeSSLPoliciesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeSSLPoliciesInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The names of the policies.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Names []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (DescribeSSLPoliciesInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s DescribeSSLPoliciesInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeSSLPoliciesInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeSSLPoliciesInput) SetNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetNames sets the Names field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeSSLPoliciesInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (DescribeSSLPoliciesInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s DescribeSSLPoliciesInput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeSSLPoliciesInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *DescribeSSLPoliciesInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeSSLPoliciesOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeSSLPoliciesOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information about the security policies.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SslPolicies []*SslPolicy `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (DescribeSSLPoliciesOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s DescribeSSLPoliciesOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*DescribeSSLPoliciesOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeSSLPoliciesOutput) SetSslPolicies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetSslPolicies sets the SslPolicies field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (DescribeSSLPoliciesOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s DescribeSSLPoliciesOutput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeTagsInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DescribeTagsInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// The Amazon Resource Names (ARN) of the resources. You can specify up to 20
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// resources in a single call.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// ResourceArns is a required field
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ResourceArns []*string `type:"list" required:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (DescribeTagsInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s DescribeTagsInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeTagsInput) SetResourceArns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *DescribeTagsInput) SetResourceArns(v []*string) *DescribeTagsInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetResourceArns sets the ResourceArns field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (DescribeTagsInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s DescribeTagsInput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeTagsInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *DescribeTagsInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeTagsOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DescribeTagsOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Information about the tags.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TagDescriptions []*TagDescription `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (DescribeTagsOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s DescribeTagsOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*DescribeTagsOutput) SetTagDescriptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *DescribeTagsOutput) SetTagDescriptions(v []*TagDescription) *DescribeTagsOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetTagDescriptions sets the TagDescriptions field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (DescribeTagsOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s DescribeTagsOutput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeTargetGroupAttributesInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeTargetGroupAttributesInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the target group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// TargetGroupArn is a required field
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TargetGroupArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (DescribeTargetGroupAttributesInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeTargetGroupAttributesInput) SetTargetGroupArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetTargetGroupArn sets the TargetGroupArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DescribeTargetGroupAttributesInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*DescribeTargetGroupAttributesInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DescribeTargetGroupAttributesOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DescribeTargetGroupAttributesOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// Information about the target group attributes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Attributes []*TargetGroupAttribute `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (DescribeTargetGroupAttributesOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeTargetGroupAttributesOutput) SetAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetAttributes sets the Attributes field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeTargetGroupAttributesOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeTargetGroupsInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeTargetGroupsInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of the load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LoadBalancerArn *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The marker for the next set of results. (You received this marker from a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// previous call.)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Marker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The names of the target groups.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Names []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The maximum number of results to return with this call.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	PageSize *int64 `min:"1" type:"integer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The Amazon Resource Names (ARN) of the target groups.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TargetGroupArns []*string `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (DescribeTargetGroupsInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s DescribeTargetGroupsInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeTargetGroupsInput) SetLoadBalancerArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetLoadBalancerArn sets the LoadBalancerArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeTargetGroupsInput) SetMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetMarker sets the Marker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*DescribeTargetGroupsInput) SetNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetNames sets the Names field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*DescribeTargetGroupsInput) SetPageSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetPageSize sets the PageSize field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeTargetGroupsInput) SetTargetGroupArns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *DescribeTargetGroupsInput) SetTargetGroupArns(v []*string) *DescribeTargetGroupsInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetTargetGroupArns sets the TargetGroupArns field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (DescribeTargetGroupsInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s DescribeTargetGroupsInput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*DescribeTargetGroupsInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *DescribeTargetGroupsInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeTargetGroupsOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DescribeTargetGroupsOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// If there are additional results, this is the marker for the next set of results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Otherwise, this is null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NextMarker *string `type:"string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Information about the target groups.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TargetGroups []*TargetGroup `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (DescribeTargetGroupsOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s DescribeTargetGroupsOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*DescribeTargetGroupsOutput) SetNextMarker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetNextMarker sets the NextMarker field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeTargetGroupsOutput) SetTargetGroups

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetTargetGroups sets the TargetGroups field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DescribeTargetGroupsOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeTargetHealthInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DescribeTargetHealthInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of the target group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// TargetGroupArn is a required field
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TargetGroupArn *string `type:"string" required:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// The targets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Targets []*TargetDescription `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (DescribeTargetHealthInput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s DescribeTargetHealthInput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*DescribeTargetHealthInput) SetTargetGroupArn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetTargetGroupArn sets the TargetGroupArn field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*DescribeTargetHealthInput) SetTargets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetTargets sets the Targets field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (DescribeTargetHealthInput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s DescribeTargetHealthInput) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*DescribeTargetHealthInput) Validate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *DescribeTargetHealthInput) Validate() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Validate inspects the fields of the type to determine if they are valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeTargetHealthOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DescribeTargetHealthOutput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Information about the health of the targets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TargetHealthDescriptions []*TargetHealthDescription `type:"list"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (DescribeTargetHealthOutput) GoString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s DescribeTargetHealthOutput) GoString() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GoString returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*DescribeTargetHealthOutput) SetTargetHealthDescriptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetTargetHealthDescriptions sets the TargetHealthDescriptions field's value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DescribeTargetHealthOutput) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String returns the string representation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ELBV2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ELBV2 struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	*client.Client
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ELBV2 provides the API operation methods for making requests to Elastic Load Balancing. See this package's package overview docs for details on the service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ELBV2 methods are safe to use concurrently. It is not safe to modify mutate any of the struct's properties though.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func New

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func New(p client.ConfigProvider, cfgs ...*aws.Config) *ELBV2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        New creates a new instance of the ELBV2 client with a session. If additional configuration is needed for the client instance use the optional aws.Config parameter to add your extra config.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mySession := session.Must(session.NewSession())
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Create a ELBV2 client from just a session.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        svc := elbv2.New(mySession)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Create a ELBV2 client with additional configuration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        svc := elbv2.New(mySession, aws.NewConfig().WithRegion("us-west-2"))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) AddListenerCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) AddListenerCertificates(input *AddListenerCertificatesInput) (*AddListenerCertificatesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AddListenerCertificates API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Adds the specified SSL server certificate to the certificate list for the specified HTTPS or TLS listener.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If the certificate in already in the certificate list, the call is successful but the certificate is not added again.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For more information, see HTTPS listeners (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html) in the Application Load Balancers Guide or TLS listeners (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html) in the Network Load Balancers Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See the AWS API reference guide for Elastic Load Balancing's API operation AddListenerCertificates for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * ErrCodeListenerNotFoundException "ListenerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The specified listener does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * ErrCodeTooManyCertificatesException "TooManyCertificates"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You've reached the limit on the number of certificates per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * ErrCodeCertificateNotFoundException "CertificateNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The specified certificate does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddListenerCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) AddListenerCertificatesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) AddListenerCertificatesRequest(input *AddListenerCertificatesInput) (req *request.Request, output *AddListenerCertificatesOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            AddListenerCertificatesRequest generates a "aws/request.Request" representing the client's request for the AddListenerCertificates operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See AddListenerCertificates for more information on using the AddListenerCertificates API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Example sending a request using the AddListenerCertificatesRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            req, resp := client.AddListenerCertificatesRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddListenerCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ELBV2) AddListenerCertificatesWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ELBV2) AddListenerCertificatesWithContext(ctx aws.Context, input *AddListenerCertificatesInput, opts ...request.Option) (*AddListenerCertificatesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AddListenerCertificatesWithContext is the same as AddListenerCertificates with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See AddListenerCertificates for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) AddTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) AddTags(input *AddTagsInput) (*AddTagsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AddTags API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Adds the specified tags to the specified Elastic Load Balancing resource. You can tag your Application Load Balancers, Network Load Balancers, Gateway Load Balancers, target groups, listeners, and rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Each tag consists of a key and an optional value. If a resource already has a tag with the same key, AddTags updates its value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See the AWS API reference guide for Elastic Load Balancing's API operation AddTags for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeDuplicateTagKeysException "DuplicateTagKeys"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A tag key was specified more than once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeTooManyTagsException "TooManyTags"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You've reached the limit on the number of tags per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified load balancer does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified target group does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To add tags to a load balancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This example adds the specified tags to the specified load balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) AddTagsRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) AddTagsRequest(input *AddTagsInput) (req *request.Request, output *AddTagsOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AddTagsRequest generates a "aws/request.Request" representing the client's request for the AddTags operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See AddTags for more information on using the AddTags API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example sending a request using the AddTagsRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    req, resp := client.AddTagsRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/AddTags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ELBV2) AddTagsWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ELBV2) AddTagsWithContext(ctx aws.Context, input *AddTagsInput, opts ...request.Option) (*AddTagsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AddTagsWithContext is the same as AddTags with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See AddTags for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) CreateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) CreateListener(input *CreateListenerInput) (*CreateListenerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CreateListener API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Creates a listener for the specified Application Load Balancer, Network Load Balancer, or Gateway Load Balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For more information, see the following:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Listeners for your Application Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Listeners for your Network Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-listeners.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Listeners for your Gateway Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-listeners.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This operation is idempotent, which means that it completes at most one time. If you attempt to create multiple listeners with the same settings, each call succeeds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See the AWS API reference guide for Elastic Load Balancing's API operation CreateListener for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeDuplicateListenerException "DuplicateListener"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A listener with the specified port already exists.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyListenersException "TooManyListeners"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of listeners per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyCertificatesException "TooManyCertificates"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of certificates per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified load balancer does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified target group does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTargetGroupAssociationLimitException "TargetGroupAssociationLimit"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of load balancers per target group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The requested configuration is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeIncompatibleProtocolsException "IncompatibleProtocols"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified configuration is not valid with this protocol.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeSSLPolicyNotFoundException "SSLPolicyNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified SSL policy does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeCertificateNotFoundException "CertificateNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified certificate does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeUnsupportedProtocolException "UnsupportedProtocol"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified protocol is not supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of times a target can be registered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        with a load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyTargetsException "TooManyTargets"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of targets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyActionsException "TooManyActions"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of actions per rule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeInvalidLoadBalancerActionException "InvalidLoadBalancerAction"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The requested action is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyUniqueTargetGroupsPerLoadBalancerException "TooManyUniqueTargetGroupsPerLoadBalancer"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of unique target groups per load balancer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        across all listeners. If a target group is used by multiple actions for a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        load balancer, it is counted as only one use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeALPNPolicyNotSupportedException "ALPNPolicyNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The specified ALPN policy is not supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * ErrCodeTooManyTagsException "TooManyTags"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You've reached the limit on the number of tags per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          To create an HTTP listener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This example creates an HTTP listener for the specified load balancer that forwards requests to the specified target group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Example (Shared01)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To create an HTTPS listener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This example creates an HTTPS listener for the specified load balancer that forwards requests to the specified target group. Note that you must specify an SSL certificate for an HTTPS listener. You can create and manage certificates using AWS Certificate Manager (ACM). Alternatively, you can create a certificate using SSL/TLS tools, get the certificate signed by a certificate authority (CA), and upload the certificate to AWS Identity and Access Management (IAM).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ELBV2) CreateListenerRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ELBV2) CreateListenerRequest(input *CreateListenerInput) (req *request.Request, output *CreateListenerOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CreateListenerRequest generates a "aws/request.Request" representing the client's request for the CreateListener operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See CreateListener for more information on using the CreateListener API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              // Example sending a request using the CreateListenerRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              req, resp := client.CreateListenerRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) CreateListenerWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) CreateListenerWithContext(ctx aws.Context, input *CreateListenerInput, opts ...request.Option) (*CreateListenerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CreateListenerWithContext is the same as CreateListener with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See CreateListener for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ELBV2) CreateLoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ELBV2) CreateLoadBalancer(input *CreateLoadBalancerInput) (*CreateLoadBalancerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CreateLoadBalancer API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Creates an Application Load Balancer, Network Load Balancer, or Gateway Load Balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For more information, see the following:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Application Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Network Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Gateway Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-load-balancers.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This operation is idempotent, which means that it completes at most one time. If you attempt to create multiple load balancers with the same settings, each call succeeds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See the AWS API reference guide for Elastic Load Balancing's API operation CreateLoadBalancer for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeDuplicateLoadBalancerNameException "DuplicateLoadBalancerName"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A load balancer with the specified name already exists.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeTooManyLoadBalancersException "TooManyLoadBalancers"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You've reached the limit on the number of load balancers for your AWS account.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The requested configuration is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeSubnetNotFoundException "SubnetNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The specified subnet does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeInvalidSubnetException "InvalidSubnet"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The specified subnet is out of available addresses.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeInvalidSecurityGroupException "InvalidSecurityGroup"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The specified security group does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeInvalidSchemeException "InvalidScheme"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The requested scheme is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeTooManyTagsException "TooManyTags"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You've reached the limit on the number of tags per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeDuplicateTagKeysException "DuplicateTagKeys"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A tag key was specified more than once.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeResourceInUseException "ResourceInUse"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A specified resource is in use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeAllocationIdNotFoundException "AllocationIdNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The specified allocation ID does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeAvailabilityZoneNotSupportedException "AvailabilityZoneNotSupported"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The specified Availability Zone is not supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * ErrCodeOperationNotPermittedException "OperationNotPermitted"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This operation is not allowed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    To create an Internet-facing load balancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This example creates an Internet-facing load balancer and enables the Availability Zones for the specified subnets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example (Shared01)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To create an internal load balancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This example creates an internal load balancer and enables the Availability Zones for the specified subnets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) CreateLoadBalancerRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) CreateLoadBalancerRequest(input *CreateLoadBalancerInput) (req *request.Request, output *CreateLoadBalancerOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CreateLoadBalancerRequest generates a "aws/request.Request" representing the client's request for the CreateLoadBalancer operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See CreateLoadBalancer for more information on using the CreateLoadBalancer API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Example sending a request using the CreateLoadBalancerRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        req, resp := client.CreateLoadBalancerRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) CreateLoadBalancerWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) CreateLoadBalancerWithContext(ctx aws.Context, input *CreateLoadBalancerInput, opts ...request.Option) (*CreateLoadBalancerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CreateLoadBalancerWithContext is the same as CreateLoadBalancer with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See CreateLoadBalancer for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) CreateRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) CreateRule(input *CreateRuleInput) (*CreateRuleOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CreateRule API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Creates a rule for the specified listener. The listener must be associated with an Application Load Balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Each rule consists of a priority, one or more actions, and one or more conditions. Rules are evaluated in priority order, from the lowest value to the highest value. When the conditions for a rule are met, its actions are performed. If the conditions for no rules are met, the actions for the default rule are performed. For more information, see Listener rules (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#listener-rules) in the Application Load Balancers Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See the AWS API reference guide for Elastic Load Balancing's API operation CreateRule for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodePriorityInUseException "PriorityInUse"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified priority is in use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyTargetGroupsException "TooManyTargetGroups"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of target groups for your AWS account.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyRulesException "TooManyRules"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of rules per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTargetGroupAssociationLimitException "TargetGroupAssociationLimit"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of load balancers per target group.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeIncompatibleProtocolsException "IncompatibleProtocols"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified configuration is not valid with this protocol.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeListenerNotFoundException "ListenerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified listener does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified target group does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The requested configuration is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyRegistrationsForTargetIdException "TooManyRegistrationsForTargetId"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of times a target can be registered
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            with a load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyTargetsException "TooManyTargets"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of targets.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeUnsupportedProtocolException "UnsupportedProtocol"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified protocol is not supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyActionsException "TooManyActions"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of actions per rule.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeInvalidLoadBalancerActionException "InvalidLoadBalancerAction"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The requested action is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyUniqueTargetGroupsPerLoadBalancerException "TooManyUniqueTargetGroupsPerLoadBalancer"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of unique target groups per load balancer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            across all listeners. If a target group is used by multiple actions for a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            load balancer, it is counted as only one use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTooManyTagsException "TooManyTags"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You've reached the limit on the number of tags per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To create a rule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This example creates a rule that forwards requests to the specified target group if the URL contains the specified pattern (for example, /img/*).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) CreateRuleRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) CreateRuleRequest(input *CreateRuleInput) (req *request.Request, output *CreateRuleOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CreateRuleRequest generates a "aws/request.Request" representing the client's request for the CreateRule operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See CreateRule for more information on using the CreateRule API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Example sending a request using the CreateRuleRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                req, resp := client.CreateRuleRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ELBV2) CreateRuleWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ELBV2) CreateRuleWithContext(ctx aws.Context, input *CreateRuleInput, opts ...request.Option) (*CreateRuleOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CreateRuleWithContext is the same as CreateRule with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See CreateRule for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) CreateTargetGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) CreateTargetGroup(input *CreateTargetGroupInput) (*CreateTargetGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CreateTargetGroup API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Creates a target group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information, see the following:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Target groups for your Application Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Target groups for your Network Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Target groups for your Gateway Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/target-groups.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This operation is idempotent, which means that it completes at most one time. If you attempt to create multiple target groups with the same settings, each call succeeds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See the AWS API reference guide for Elastic Load Balancing's API operation CreateTargetGroup for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeDuplicateTargetGroupNameException "DuplicateTargetGroupName"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A target group with the specified name already exists.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeTooManyTargetGroupsException "TooManyTargetGroups"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You've reached the limit on the number of target groups for your AWS account.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeInvalidConfigurationRequestException "InvalidConfigurationRequest"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The requested configuration is not valid.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeTooManyTagsException "TooManyTags"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You've reached the limit on the number of tags per load balancer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateTargetGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To create a target group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This example creates a target group that you can use to route traffic to targets using HTTP on port 80. This target group uses the default health check configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) CreateTargetGroupRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) CreateTargetGroupRequest(input *CreateTargetGroupInput) (req *request.Request, output *CreateTargetGroupOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CreateTargetGroupRequest generates a "aws/request.Request" representing the client's request for the CreateTargetGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See CreateTargetGroup for more information on using the CreateTargetGroup API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Example sending a request using the CreateTargetGroupRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        req, resp := client.CreateTargetGroupRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/CreateTargetGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) CreateTargetGroupWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) CreateTargetGroupWithContext(ctx aws.Context, input *CreateTargetGroupInput, opts ...request.Option) (*CreateTargetGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CreateTargetGroupWithContext is the same as CreateTargetGroup with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See CreateTargetGroup for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) DeleteListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) DeleteListener(input *DeleteListenerInput) (*DeleteListenerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DeleteListener API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deletes the specified listener.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Alternatively, your listener is deleted when you delete the load balancer to which it is attached.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See the AWS API reference guide for Elastic Load Balancing's API operation DeleteListener for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeListenerNotFoundException "ListenerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified listener does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To delete a listener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This example deletes the specified listener.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) DeleteListenerRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) DeleteListenerRequest(input *DeleteListenerInput) (req *request.Request, output *DeleteListenerOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DeleteListenerRequest generates a "aws/request.Request" representing the client's request for the DeleteListener operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See DeleteListener for more information on using the DeleteListener API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Example sending a request using the DeleteListenerRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                req, resp := client.DeleteListenerRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ELBV2) DeleteListenerWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ELBV2) DeleteListenerWithContext(ctx aws.Context, input *DeleteListenerInput, opts ...request.Option) (*DeleteListenerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DeleteListenerWithContext is the same as DeleteListener with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See DeleteListener for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) DeleteLoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) DeleteLoadBalancer(input *DeleteLoadBalancerInput) (*DeleteLoadBalancerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DeleteLoadBalancer API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deletes the specified Application Load Balancer, Network Load Balancer, or Gateway Load Balancer. Deleting a load balancer also deletes its listeners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can't delete a load balancer if deletion protection is enabled. If the load balancer does not exist or has already been deleted, the call succeeds.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deleting a load balancer does not affect its registered targets. For example, your EC2 instances continue to run and are still registered to their target groups. If you no longer need these EC2 instances, you can stop or terminate them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See the AWS API reference guide for Elastic Load Balancing's API operation DeleteLoadBalancer for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The specified load balancer does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeOperationNotPermittedException "OperationNotPermitted"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This operation is not allowed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeResourceInUseException "ResourceInUse"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A specified resource is in use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteLoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To delete a load balancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This example deletes the specified load balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) DeleteLoadBalancerRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) DeleteLoadBalancerRequest(input *DeleteLoadBalancerInput) (req *request.Request, output *DeleteLoadBalancerOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DeleteLoadBalancerRequest generates a "aws/request.Request" representing the client's request for the DeleteLoadBalancer operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See DeleteLoadBalancer for more information on using the DeleteLoadBalancer API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Example sending a request using the DeleteLoadBalancerRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        req, resp := client.DeleteLoadBalancerRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteLoadBalancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) DeleteLoadBalancerWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) DeleteLoadBalancerWithContext(ctx aws.Context, input *DeleteLoadBalancerInput, opts ...request.Option) (*DeleteLoadBalancerOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DeleteLoadBalancerWithContext is the same as DeleteLoadBalancer with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See DeleteLoadBalancer for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) DeleteRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) DeleteRule(input *DeleteRuleInput) (*DeleteRuleOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DeleteRule API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deletes the specified rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You can't delete the default rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See the AWS API reference guide for Elastic Load Balancing's API operation DeleteRule for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeRuleNotFoundException "RuleNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified rule does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeOperationNotPermittedException "OperationNotPermitted"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This operation is not allowed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To delete a rule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This example deletes the specified rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) DeleteRuleRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) DeleteRuleRequest(input *DeleteRuleInput) (req *request.Request, output *DeleteRuleOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DeleteRuleRequest generates a "aws/request.Request" representing the client's request for the DeleteRule operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See DeleteRule for more information on using the DeleteRule API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Example sending a request using the DeleteRuleRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                req, resp := client.DeleteRuleRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ELBV2) DeleteRuleWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ELBV2) DeleteRuleWithContext(ctx aws.Context, input *DeleteRuleInput, opts ...request.Option) (*DeleteRuleOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DeleteRuleWithContext is the same as DeleteRule with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See DeleteRule for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) DeleteTargetGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) DeleteTargetGroup(input *DeleteTargetGroupInput) (*DeleteTargetGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DeleteTargetGroup API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deletes the specified target group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    You can delete a target group if it is not referenced by any actions. Deleting a target group also deletes any associated health checks. Deleting a target group does not affect its registered targets. For example, any EC2 instances continue to run until you stop or terminate them.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See the AWS API reference guide for Elastic Load Balancing's API operation DeleteTargetGroup for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeResourceInUseException "ResourceInUse"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A specified resource is in use.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteTargetGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To delete a target group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This example deletes the specified target group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) DeleteTargetGroupRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) DeleteTargetGroupRequest(input *DeleteTargetGroupInput) (req *request.Request, output *DeleteTargetGroupOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DeleteTargetGroupRequest generates a "aws/request.Request" representing the client's request for the DeleteTargetGroup operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See DeleteTargetGroup for more information on using the DeleteTargetGroup API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Example sending a request using the DeleteTargetGroupRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        req, resp := client.DeleteTargetGroupRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeleteTargetGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) DeleteTargetGroupWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) DeleteTargetGroupWithContext(ctx aws.Context, input *DeleteTargetGroupInput, opts ...request.Option) (*DeleteTargetGroupOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DeleteTargetGroupWithContext is the same as DeleteTargetGroup with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See DeleteTargetGroup for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) DeregisterTargets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) DeregisterTargets(input *DeregisterTargetsInput) (*DeregisterTargetsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DeregisterTargets API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deregisters the specified targets from the specified target group. After the targets are deregistered, they no longer receive traffic from the load balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See the AWS API reference guide for Elastic Load Balancing's API operation DeregisterTargets for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeTargetGroupNotFoundException "TargetGroupNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified target group does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeInvalidTargetException "InvalidTarget"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified target does not exist, is not in the same VPC as the target
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            group, or has an unsupported instance type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeregisterTargets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To deregister a target from a target group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This example deregisters the specified instance from the specified target group.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) DeregisterTargetsRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) DeregisterTargetsRequest(input *DeregisterTargetsInput) (req *request.Request, output *DeregisterTargetsOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DeregisterTargetsRequest generates a "aws/request.Request" representing the client's request for the DeregisterTargets operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See DeregisterTargets for more information on using the DeregisterTargets API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Example sending a request using the DeregisterTargetsRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                req, resp := client.DeregisterTargetsRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DeregisterTargets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ELBV2) DeregisterTargetsWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ELBV2) DeregisterTargetsWithContext(ctx aws.Context, input *DeregisterTargetsInput, opts ...request.Option) (*DeregisterTargetsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DeregisterTargetsWithContext is the same as DeregisterTargets with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See DeregisterTargets for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) DescribeAccountLimits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) DescribeAccountLimits(input *DescribeAccountLimitsInput) (*DescribeAccountLimitsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DescribeAccountLimits API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes the current Elastic Load Balancing resource limits for your AWS account.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For more information, see the following:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Quotas for your Application Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-limits.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Quotas for your Network Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-limits.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * Quotas for your Gateway Load Balancers (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/quotas-limits.html)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See the AWS API reference guide for Elastic Load Balancing's API operation DescribeAccountLimits for usage and error information. See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeAccountLimits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ELBV2) DescribeAccountLimitsRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ELBV2) DescribeAccountLimitsRequest(input *DescribeAccountLimitsInput) (req *request.Request, output *DescribeAccountLimitsOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DescribeAccountLimitsRequest generates a "aws/request.Request" representing the client's request for the DescribeAccountLimits operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See DescribeAccountLimits for more information on using the DescribeAccountLimits API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // Example sending a request using the DescribeAccountLimitsRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      req, resp := client.DescribeAccountLimitsRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeAccountLimits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) DescribeAccountLimitsWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) DescribeAccountLimitsWithContext(ctx aws.Context, input *DescribeAccountLimitsInput, opts ...request.Option) (*DescribeAccountLimitsOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DescribeAccountLimitsWithContext is the same as DescribeAccountLimits with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See DescribeAccountLimits for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) DescribeListenerCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) DescribeListenerCertificates(input *DescribeListenerCertificatesInput) (*DescribeListenerCertificatesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DescribeListenerCertificates API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Describes the default certificate and the certificate list for the specified HTTPS or TLS listener.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If the default certificate is also in the certificate list, it appears twice in the results (once with IsDefault set to true and once with IsDefault set to false).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For more information, see SSL certificates (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#https-listener-certificates) in the Application Load Balancers Guide or Server certificates (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#tls-listener-certificate) in the Network Load Balancers Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See the AWS API reference guide for Elastic Load Balancing's API operation DescribeListenerCertificates for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * ErrCodeListenerNotFoundException "ListenerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The specified listener does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListenerCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) DescribeListenerCertificatesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) DescribeListenerCertificatesRequest(input *DescribeListenerCertificatesInput) (req *request.Request, output *DescribeListenerCertificatesOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DescribeListenerCertificatesRequest generates a "aws/request.Request" representing the client's request for the DescribeListenerCertificates operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See DescribeListenerCertificates for more information on using the DescribeListenerCertificates API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Example sending a request using the DescribeListenerCertificatesRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            req, resp := client.DescribeListenerCertificatesRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListenerCertificates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ELBV2) DescribeListenerCertificatesWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ELBV2) DescribeListenerCertificatesWithContext(ctx aws.Context, input *DescribeListenerCertificatesInput, opts ...request.Option) (*DescribeListenerCertificatesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DescribeListenerCertificatesWithContext is the same as DescribeListenerCertificates with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See DescribeListenerCertificates for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) DescribeListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) DescribeListeners(input *DescribeListenersInput) (*DescribeListenersOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DescribeListeners API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the specified listeners or the listeners for the specified Application Load Balancer, Network Load Balancer, or Gateway Load Balancer. You must specify either a load balancer or one or more listeners.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See the AWS API reference guide for Elastic Load Balancing's API operation DescribeListeners for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeListenerNotFoundException "ListenerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified listener does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified load balancer does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeUnsupportedProtocolException "UnsupportedProtocol"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified protocol is not supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To describe a listener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This example describes the specified listener.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) DescribeListenersPages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) DescribeListenersPages(input *DescribeListenersInput, fn func(*DescribeListenersOutput, bool) bool) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DescribeListenersPages iterates over the pages of a DescribeListeners operation, calling the "fn" function with the response data for each page. To stop iterating, return false from the fn function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See DescribeListeners method for more information on how to use this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Note: This operation can generate multiple requests to a service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example iterating over at most 3 pages of a DescribeListeners operation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pageNum := 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    err := client.DescribeListenersPages(params,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func(page *elbv2.DescribeListenersOutput, lastPage bool) bool {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageNum++
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fmt.Println(page)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            return pageNum <= 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ELBV2) DescribeListenersPagesWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ELBV2) DescribeListenersPagesWithContext(ctx aws.Context, input *DescribeListenersInput, fn func(*DescribeListenersOutput, bool) bool, opts ...request.Option) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DescribeListenersPagesWithContext same as DescribeListenersPages except it takes a Context and allows setting request options on the pages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) DescribeListenersRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) DescribeListenersRequest(input *DescribeListenersInput) (req *request.Request, output *DescribeListenersOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DescribeListenersRequest generates a "aws/request.Request" representing the client's request for the DescribeListeners operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See DescribeListeners for more information on using the DescribeListeners API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Example sending a request using the DescribeListenersRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        req, resp := client.DescribeListenersRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) DescribeListenersWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) DescribeListenersWithContext(ctx aws.Context, input *DescribeListenersInput, opts ...request.Option) (*DescribeListenersOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DescribeListenersWithContext is the same as DescribeListeners with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          See DescribeListeners for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) DescribeLoadBalancerAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) DescribeLoadBalancerAttributes(input *DescribeLoadBalancerAttributesInput) (*DescribeLoadBalancerAttributesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DescribeLoadBalancerAttributes API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Describes the attributes for the specified Application Load Balancer, Network Load Balancer, or Gateway Load Balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For more information, see the following:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * Load balancer attributes (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html#load-balancer-attributes)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            in the Application Load Balancers Guide
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * Load balancer attributes (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#load-balancer-attributes)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            in the Network Load Balancers Guide
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * Load balancer attributes (https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/gateway-load-balancers.html#load-balancer-attributes)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            in the Gateway Load Balancers Guide
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See the AWS API reference guide for Elastic Load Balancing's API operation DescribeLoadBalancerAttributes for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The specified load balancer does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancerAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To describe load balancer attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              This example describes the attributes of the specified load balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) DescribeLoadBalancerAttributesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) DescribeLoadBalancerAttributesRequest(input *DescribeLoadBalancerAttributesInput) (req *request.Request, output *DescribeLoadBalancerAttributesOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DescribeLoadBalancerAttributesRequest generates a "aws/request.Request" representing the client's request for the DescribeLoadBalancerAttributes operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See DescribeLoadBalancerAttributes for more information on using the DescribeLoadBalancerAttributes API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // Example sending a request using the DescribeLoadBalancerAttributesRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                req, resp := client.DescribeLoadBalancerAttributesRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancerAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ELBV2) DescribeLoadBalancerAttributesWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c *ELBV2) DescribeLoadBalancerAttributesWithContext(ctx aws.Context, input *DescribeLoadBalancerAttributesInput, opts ...request.Option) (*DescribeLoadBalancerAttributesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DescribeLoadBalancerAttributesWithContext is the same as DescribeLoadBalancerAttributes with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  See DescribeLoadBalancerAttributes for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) DescribeLoadBalancers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) DescribeLoadBalancers(input *DescribeLoadBalancersInput) (*DescribeLoadBalancersOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DescribeLoadBalancers API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Describes the specified load balancers or all of your load balancers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See the AWS API reference guide for Elastic Load Balancing's API operation DescribeLoadBalancers for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * ErrCodeLoadBalancerNotFoundException "LoadBalancerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The specified load balancer does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To describe a load balancer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      This example describes the specified load balancer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) DescribeLoadBalancersPages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) DescribeLoadBalancersPages(input *DescribeLoadBalancersInput, fn func(*DescribeLoadBalancersOutput, bool) bool) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DescribeLoadBalancersPages iterates over the pages of a DescribeLoadBalancers operation, calling the "fn" function with the response data for each page. To stop iterating, return false from the fn function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See DescribeLoadBalancers method for more information on how to use this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Note: This operation can generate multiple requests to a service.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Example iterating over at most 3 pages of a DescribeLoadBalancers operation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pageNum := 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err := client.DescribeLoadBalancersPages(params,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func(page *elbv2.DescribeLoadBalancersOutput, lastPage bool) bool {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pageNum++
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fmt.Println(page)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                return pageNum <= 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            })
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ELBV2) DescribeLoadBalancersPagesWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *ELBV2) DescribeLoadBalancersPagesWithContext(ctx aws.Context, input *DescribeLoadBalancersInput, fn func(*DescribeLoadBalancersOutput, bool) bool, opts ...request.Option) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DescribeLoadBalancersPagesWithContext same as DescribeLoadBalancersPages except it takes a Context and allows setting request options on the pages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ELBV2) DescribeLoadBalancersRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *ELBV2) DescribeLoadBalancersRequest(input *DescribeLoadBalancersInput) (req *request.Request, output *DescribeLoadBalancersOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DescribeLoadBalancersRequest generates a "aws/request.Request" representing the client's request for the DescribeLoadBalancers operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See DescribeLoadBalancers for more information on using the DescribeLoadBalancers API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Example sending a request using the DescribeLoadBalancersRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            req, resp := client.DescribeLoadBalancersRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeLoadBalancers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ELBV2) DescribeLoadBalancersWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c *ELBV2) DescribeLoadBalancersWithContext(ctx aws.Context, input *DescribeLoadBalancersInput, opts ...request.Option) (*DescribeLoadBalancersOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DescribeLoadBalancersWithContext is the same as DescribeLoadBalancers with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              See DescribeLoadBalancers for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ELBV2) DescribeRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c *ELBV2) DescribeRules(input *DescribeRulesInput) (*DescribeRulesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DescribeRules API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Describes the specified rules or the rules for the specified listener. You must specify either a listener or one or more rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See the AWS API reference guide for Elastic Load Balancing's API operation DescribeRules for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returned Error Codes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeListenerNotFoundException "ListenerNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified listener does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeRuleNotFoundException "RuleNotFound"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified rule does not exist.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * ErrCodeUnsupportedProtocolException "UnsupportedProtocol"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The specified protocol is not supported.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example (Shared00)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  To describe a rule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This example describes the specified rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Output:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ELBV2) DescribeRulesRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ELBV2) DescribeRulesRequest(input *DescribeRulesInput) (req *request.Request, output *DescribeRulesOutput)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DescribeRulesRequest generates a "aws/request.Request" representing the client's request for the DescribeRules operation. The "output" return value will be populated with the request's response once the request completes successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use "Send" method on the returned Request to send the API call to the service. the "output" return value is not valid until after Send returns without error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See DescribeRules for more information on using the DescribeRules API call, and error handling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This method is useful when you want to inject custom logic or configuration into the SDK's request lifecycle. Such as custom headers, or retry logic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Example sending a request using the DescribeRulesRequest method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    req, resp := client.DescribeRulesRequest(params)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    err := req.Send()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if err == nil { // resp is now filled
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fmt.Println(resp)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See also, https://docs.aws.amazon.com/goto/WebAPI/elasticloadbalancingv2-2015-12-01/DescribeRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ELBV2) DescribeRulesWithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *ELBV2) DescribeRulesWithContext(ctx aws.Context, input *DescribeRulesInput, opts ...request.Option) (*DescribeRulesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DescribeRulesWithContext is the same as DescribeRules with the addition of the ability to pass a context and additional request options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      See DescribeRules for details on how to use this API operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The context must be non-nil and will be used for request cancellation. If the context is nil a panic will occur. In the future the SDK may create sub-contexts for http.Requests. See https://golang.org/pkg/context/ for more information on using Contexts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ELBV2) DescribeSSLPolicies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c *ELBV2) DescribeSSLPolicies(input *DescribeSSLPoliciesInput) (*DescribeSSLPoliciesOutput, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DescribeSSLPolicies API operation for Elastic Load Balancing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Describes the specified policies or all policies used for SSL negotiation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For more information, see Security policies (https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies) in the Application Load Balancers Guide or Security policies (https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#describe-ssl-policies) in the Network Load Balancers Guide.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Returns awserr.Error for service API and SDK errors. Use runtime type assertions with awserr.Error's Code and Message methods to get detailed information about the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See the AWS API reference guide for Elastic Load Balancing's API operation DescribeSSLPolicies for usage and error information.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Re