Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessLog

type AccessLog struct {

	// Specifies whether access logs are enabled for the load balancer.
	//
	// This member is required.
	Enabled bool

	// The interval for publishing the access logs. You can specify an interval of
	// either 5 minutes or 60 minutes. Default: 60 minutes
	EmitInterval *int32

	// The name of the Amazon S3 bucket where the access logs are stored.
	S3BucketName *string

	// The logical hierarchy you created for your Amazon S3 bucket, for example
	// my-bucket-prefix/prod. If the prefix is not provided, the log is placed at the
	// root level of the bucket.
	S3BucketPrefix *string
}

    Information about the AccessLog attribute.

    type AccessPointNotFoundException

    type AccessPointNotFoundException struct {
    	Message *string
    }

      The specified load balancer does not exist.

      func (*AccessPointNotFoundException) Error

      func (*AccessPointNotFoundException) ErrorCode

      func (e *AccessPointNotFoundException) ErrorCode() string

      func (*AccessPointNotFoundException) ErrorFault

      func (*AccessPointNotFoundException) ErrorMessage

      func (e *AccessPointNotFoundException) ErrorMessage() string

      type AdditionalAttribute

      type AdditionalAttribute struct {
      
      	// The name of the attribute. The following attribute is supported.
      	//
      	// *
      	// elb.http.desyncmitigationmode - Determines how the load balancer handles
      	// requests that might pose a security risk to your application. The possible
      	// values are monitor, defensive, and strictest. The default is defensive.
      	Key *string
      
      	// This value of the attribute.
      	Value *string
      }

        Information about additional load balancer attributes.

        type AppCookieStickinessPolicy

        type AppCookieStickinessPolicy struct {
        
        	// The name of the application cookie used for stickiness.
        	CookieName *string
        
        	// The mnemonic name for the policy being created. The name must be unique within a
        	// set of policies for this load balancer.
        	PolicyName *string
        }

          Information about a policy for application-controlled session stickiness.

          type BackendServerDescription

          type BackendServerDescription struct {
          
          	// The port on which the EC2 instance is listening.
          	InstancePort int32
          
          	// The names of the policies enabled for the EC2 instance.
          	PolicyNames []string
          }

            Information about the configuration of an EC2 instance.

            type CertificateNotFoundException

            type CertificateNotFoundException struct {
            	Message *string
            }

              The specified ARN does not refer to a valid SSL certificate in AWS Identity and Access Management (IAM) or AWS Certificate Manager (ACM). Note that if you recently uploaded the certificate to IAM, this error might indicate that the certificate is not fully available yet.

              func (*CertificateNotFoundException) Error

              func (*CertificateNotFoundException) ErrorCode

              func (e *CertificateNotFoundException) ErrorCode() string

              func (*CertificateNotFoundException) ErrorFault

              func (*CertificateNotFoundException) ErrorMessage

              func (e *CertificateNotFoundException) ErrorMessage() string

              type ConnectionDraining

              type ConnectionDraining struct {
              
              	// Specifies whether connection draining is enabled for the load balancer.
              	//
              	// This member is required.
              	Enabled bool
              
              	// The maximum time, in seconds, to keep the existing connections open before
              	// deregistering the instances.
              	Timeout *int32
              }

                Information about the ConnectionDraining attribute.

                type ConnectionSettings

                type ConnectionSettings struct {
                
                	// The time, in seconds, that the connection is allowed to be idle (no data has
                	// been sent over the connection) before it is closed by the load balancer.
                	//
                	// This member is required.
                	IdleTimeout *int32
                }

                  Information about the ConnectionSettings attribute.

                  type CrossZoneLoadBalancing

                  type CrossZoneLoadBalancing struct {
                  
                  	// Specifies whether cross-zone load balancing is enabled for the load balancer.
                  	//
                  	// This member is required.
                  	Enabled bool
                  }

                    Information about the CrossZoneLoadBalancing attribute.

                    type DependencyThrottleException

                    type DependencyThrottleException struct {
                    	Message *string
                    }

                      A request made by Elastic Load Balancing to another service exceeds the maximum request rate permitted for your account.

                      func (*DependencyThrottleException) Error

                      func (*DependencyThrottleException) ErrorCode

                      func (e *DependencyThrottleException) ErrorCode() string

                      func (*DependencyThrottleException) ErrorFault

                      func (*DependencyThrottleException) ErrorMessage

                      func (e *DependencyThrottleException) ErrorMessage() string

                      type DuplicateAccessPointNameException

                      type DuplicateAccessPointNameException struct {
                      	Message *string
                      }

                        The specified load balancer name already exists for this account.

                        func (*DuplicateAccessPointNameException) Error

                        func (*DuplicateAccessPointNameException) ErrorCode

                        func (*DuplicateAccessPointNameException) ErrorFault

                        func (*DuplicateAccessPointNameException) ErrorMessage

                        func (e *DuplicateAccessPointNameException) ErrorMessage() string

                        type DuplicateListenerException

                        type DuplicateListenerException struct {
                        	Message *string
                        }

                          A listener already exists for the specified load balancer name and port, but with a different instance port, protocol, or SSL certificate.

                          func (*DuplicateListenerException) Error

                          func (*DuplicateListenerException) ErrorCode

                          func (e *DuplicateListenerException) ErrorCode() string

                          func (*DuplicateListenerException) ErrorFault

                          func (*DuplicateListenerException) ErrorMessage

                          func (e *DuplicateListenerException) ErrorMessage() string

                          type DuplicatePolicyNameException

                          type DuplicatePolicyNameException struct {
                          	Message *string
                          }

                            A policy with the specified name already exists for this load balancer.

                            func (*DuplicatePolicyNameException) Error

                            func (*DuplicatePolicyNameException) ErrorCode

                            func (e *DuplicatePolicyNameException) ErrorCode() string

                            func (*DuplicatePolicyNameException) ErrorFault

                            func (*DuplicatePolicyNameException) ErrorMessage

                            func (e *DuplicatePolicyNameException) ErrorMessage() string

                            type DuplicateTagKeysException

                            type DuplicateTagKeysException struct {
                            	Message *string
                            }

                              A tag key was specified more than once.

                              func (*DuplicateTagKeysException) Error

                              func (e *DuplicateTagKeysException) Error() string

                              func (*DuplicateTagKeysException) ErrorCode

                              func (e *DuplicateTagKeysException) ErrorCode() string

                              func (*DuplicateTagKeysException) ErrorFault

                              func (*DuplicateTagKeysException) ErrorMessage

                              func (e *DuplicateTagKeysException) ErrorMessage() string

                              type HealthCheck

                              type HealthCheck struct {
                              
                              	// The number of consecutive health checks successes required before moving the
                              	// instance to the Healthy state.
                              	//
                              	// This member is required.
                              	HealthyThreshold int32
                              
                              	// The approximate interval, in seconds, between health checks of an individual
                              	// instance.
                              	//
                              	// This member is required.
                              	Interval int32
                              
                              	// The instance being checked. The protocol is either TCP, HTTP, HTTPS, or SSL. The
                              	// range of valid ports is one (1) through 65535. TCP is the default, specified as
                              	// a TCP: port pair, for example "TCP:5000". In this case, a health check simply
                              	// attempts to open a TCP connection to the instance on the specified port. Failure
                              	// to connect within the configured timeout is considered unhealthy. SSL is also
                              	// specified as SSL: port pair, for example, SSL:5000. For HTTP/HTTPS, you must
                              	// include a ping path in the string. HTTP is specified as a
                              	// HTTP:port;/;PathToPing; grouping, for example "HTTP:80/weather/us/wa/seattle".
                              	// In this case, a HTTP GET request is issued to the instance on the given port and
                              	// path. Any answer other than "200 OK" within the timeout period is considered
                              	// unhealthy. The total length of the HTTP ping target must be 1024 16-bit Unicode
                              	// characters or less.
                              	//
                              	// This member is required.
                              	Target *string
                              
                              	// The amount of time, in seconds, during which no response means a failed health
                              	// check. This value must be less than the Interval value.
                              	//
                              	// This member is required.
                              	Timeout int32
                              
                              	// The number of consecutive health check failures required before moving the
                              	// instance to the Unhealthy state.
                              	//
                              	// This member is required.
                              	UnhealthyThreshold int32
                              }

                                Information about a health check.

                                type Instance

                                type Instance struct {
                                
                                	// The instance ID.
                                	InstanceId *string
                                }

                                  The ID of an EC2 instance.

                                  type InstanceState

                                  type InstanceState struct {
                                  
                                  	// A description of the instance state. This string can contain one or more of the
                                  	// following messages.
                                  	//
                                  	// * N/A
                                  	//
                                  	// * A transient error occurred. Please try again
                                  	// later.
                                  	//
                                  	// * Instance has failed at least the UnhealthyThreshold number of health
                                  	// checks consecutively.
                                  	//
                                  	// * Instance has not passed the configured HealthyThreshold
                                  	// number of health checks consecutively.
                                  	//
                                  	// * Instance registration is still in
                                  	// progress.
                                  	//
                                  	// * Instance is in the EC2 Availability Zone for which LoadBalancer is
                                  	// not configured to route traffic to.
                                  	//
                                  	// * Instance is not currently registered with
                                  	// the LoadBalancer.
                                  	//
                                  	// * Instance deregistration currently in progress.
                                  	//
                                  	// * Disable
                                  	// Availability Zone is currently in progress.
                                  	//
                                  	// * Instance is in pending state.
                                  	//
                                  	// *
                                  	// Instance is in stopped state.
                                  	//
                                  	// * Instance is in terminated state.
                                  	Description *string
                                  
                                  	// The ID of the instance.
                                  	InstanceId *string
                                  
                                  	// Information about the cause of OutOfService instances. Specifically, whether the
                                  	// cause is Elastic Load Balancing or the instance. Valid values: ELB | Instance |
                                  	// N/A
                                  	ReasonCode *string
                                  
                                  	// The current state of the instance. Valid values: InService | OutOfService |
                                  	// Unknown
                                  	State *string
                                  }

                                    Information about the state of an EC2 instance.

                                    type InvalidConfigurationRequestException

                                    type InvalidConfigurationRequestException struct {
                                    	Message *string
                                    }

                                      The requested configuration change is not valid.

                                      func (*InvalidConfigurationRequestException) Error

                                      func (*InvalidConfigurationRequestException) ErrorCode

                                      func (*InvalidConfigurationRequestException) ErrorFault

                                      func (*InvalidConfigurationRequestException) ErrorMessage

                                      func (e *InvalidConfigurationRequestException) ErrorMessage() string

                                      type InvalidEndPointException

                                      type InvalidEndPointException struct {
                                      	Message *string
                                      }

                                        The specified endpoint is not valid.

                                        func (*InvalidEndPointException) Error

                                        func (e *InvalidEndPointException) Error() string

                                        func (*InvalidEndPointException) ErrorCode

                                        func (e *InvalidEndPointException) ErrorCode() string

                                        func (*InvalidEndPointException) ErrorFault

                                        func (e *InvalidEndPointException) ErrorFault() smithy.ErrorFault

                                        func (*InvalidEndPointException) ErrorMessage

                                        func (e *InvalidEndPointException) ErrorMessage() string

                                        type InvalidSchemeException

                                        type InvalidSchemeException struct {
                                        	Message *string
                                        }

                                          The specified value for the schema is not valid. You can only specify a scheme for load balancers in a VPC.

                                          func (*InvalidSchemeException) Error

                                          func (e *InvalidSchemeException) Error() string

                                          func (*InvalidSchemeException) ErrorCode

                                          func (e *InvalidSchemeException) ErrorCode() string

                                          func (*InvalidSchemeException) ErrorFault

                                          func (e *InvalidSchemeException) ErrorFault() smithy.ErrorFault

                                          func (*InvalidSchemeException) ErrorMessage

                                          func (e *InvalidSchemeException) ErrorMessage() string

                                          type InvalidSecurityGroupException

                                          type InvalidSecurityGroupException struct {
                                          	Message *string
                                          }

                                            One or more of the specified security groups do not exist.

                                            func (*InvalidSecurityGroupException) Error

                                            func (*InvalidSecurityGroupException) ErrorCode

                                            func (e *InvalidSecurityGroupException) ErrorCode() string

                                            func (*InvalidSecurityGroupException) ErrorFault

                                            func (*InvalidSecurityGroupException) ErrorMessage

                                            func (e *InvalidSecurityGroupException) ErrorMessage() string

                                            type InvalidSubnetException

                                            type InvalidSubnetException struct {
                                            	Message *string
                                            }

                                              The specified VPC has no associated Internet gateway.

                                              func (*InvalidSubnetException) Error

                                              func (e *InvalidSubnetException) Error() string

                                              func (*InvalidSubnetException) ErrorCode

                                              func (e *InvalidSubnetException) ErrorCode() string

                                              func (*InvalidSubnetException) ErrorFault

                                              func (e *InvalidSubnetException) ErrorFault() smithy.ErrorFault

                                              func (*InvalidSubnetException) ErrorMessage

                                              func (e *InvalidSubnetException) ErrorMessage() string

                                              type LBCookieStickinessPolicy

                                              type LBCookieStickinessPolicy struct {
                                              
                                              	// The time period, in seconds, after which the cookie should be considered stale.
                                              	// If this parameter is not specified, the stickiness session lasts for the
                                              	// duration of the browser session.
                                              	CookieExpirationPeriod *int64
                                              
                                              	// The name of the policy. This name must be unique within the set of policies for
                                              	// this load balancer.
                                              	PolicyName *string
                                              }

                                                Information about a policy for duration-based session stickiness.

                                                type Limit

                                                type Limit struct {
                                                
                                                	// The maximum value of the limit.
                                                	Max *string
                                                
                                                	// The name of the limit. The possible values are:
                                                	//
                                                	// * classic-listeners
                                                	//
                                                	// *
                                                	// classic-load-balancers
                                                	//
                                                	// * classic-registered-instances
                                                	Name *string
                                                }

                                                  Information about an Elastic Load Balancing resource limit for your AWS account.

                                                  type Listener

                                                  type Listener struct {
                                                  
                                                  	// The port on which the instance is listening.
                                                  	//
                                                  	// This member is required.
                                                  	InstancePort int32
                                                  
                                                  	// The port on which the load balancer is listening. On EC2-VPC, you can specify
                                                  	// any port from the range 1-65535. On EC2-Classic, you can specify any port from
                                                  	// the following list: 25, 80, 443, 465, 587, 1024-65535.
                                                  	//
                                                  	// This member is required.
                                                  	LoadBalancerPort int32
                                                  
                                                  	// The load balancer transport protocol to use for routing: HTTP, HTTPS, TCP, or
                                                  	// SSL.
                                                  	//
                                                  	// This member is required.
                                                  	Protocol *string
                                                  
                                                  	// The protocol to use for routing traffic to instances: HTTP, HTTPS, TCP, or SSL.
                                                  	// If the front-end protocol is TCP or SSL, the back-end protocol must be TCP or
                                                  	// SSL. If the front-end protocol is HTTP or HTTPS, the back-end protocol must be
                                                  	// HTTP or HTTPS. If there is another listener with the same InstancePort whose
                                                  	// InstanceProtocol is secure, (HTTPS or SSL), the listener's InstanceProtocol must
                                                  	// also be secure. If there is another listener with the same InstancePort whose
                                                  	// InstanceProtocol is HTTP or TCP, the listener's InstanceProtocol must be HTTP or
                                                  	// TCP.
                                                  	InstanceProtocol *string
                                                  
                                                  	// The Amazon Resource Name (ARN) of the server certificate.
                                                  	SSLCertificateId *string
                                                  }

                                                    Information about a listener. For information about the protocols and the ports supported by Elastic Load Balancing, see Listeners for Your Classic Load Balancer (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-listener-config.html) in the Classic Load Balancers Guide.

                                                    type ListenerDescription

                                                    type ListenerDescription struct {
                                                    
                                                    	// The listener.
                                                    	Listener *Listener
                                                    
                                                    	// The policies. If there are no policies enabled, the list is empty.
                                                    	PolicyNames []string
                                                    }

                                                      The policies enabled for a listener.

                                                      type ListenerNotFoundException

                                                      type ListenerNotFoundException struct {
                                                      	Message *string
                                                      }

                                                        The load balancer does not have a listener configured at the specified port.

                                                        func (*ListenerNotFoundException) Error

                                                        func (e *ListenerNotFoundException) Error() string

                                                        func (*ListenerNotFoundException) ErrorCode

                                                        func (e *ListenerNotFoundException) ErrorCode() string

                                                        func (*ListenerNotFoundException) ErrorFault

                                                        func (*ListenerNotFoundException) ErrorMessage

                                                        func (e *ListenerNotFoundException) ErrorMessage() string

                                                        type LoadBalancerAttributeNotFoundException

                                                        type LoadBalancerAttributeNotFoundException struct {
                                                        	Message *string
                                                        }

                                                          The specified load balancer attribute does not exist.

                                                          func (*LoadBalancerAttributeNotFoundException) Error

                                                          func (*LoadBalancerAttributeNotFoundException) ErrorCode

                                                          func (*LoadBalancerAttributeNotFoundException) ErrorFault

                                                          func (*LoadBalancerAttributeNotFoundException) ErrorMessage

                                                          type LoadBalancerAttributes

                                                          type LoadBalancerAttributes struct {
                                                          
                                                          	// If enabled, the load balancer captures detailed information of all requests and
                                                          	// delivers the information to the Amazon S3 bucket that you specify. For more
                                                          	// information, see Enable Access Logs
                                                          	// (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html)
                                                          	// in the Classic Load Balancers Guide.
                                                          	AccessLog *AccessLog
                                                          
                                                          	// Any additional attributes.
                                                          	AdditionalAttributes []AdditionalAttribute
                                                          
                                                          	// If enabled, the load balancer allows existing requests to complete before the
                                                          	// load balancer shifts traffic away from a deregistered or unhealthy instance. For
                                                          	// more information, see Configure Connection Draining
                                                          	// (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-conn-drain.html)
                                                          	// in the Classic Load Balancers Guide.
                                                          	ConnectionDraining *ConnectionDraining
                                                          
                                                          	// If enabled, the load balancer allows the connections to remain idle (no data is
                                                          	// sent over the connection) for the specified duration. By default, Elastic Load
                                                          	// Balancing maintains a 60-second idle connection timeout for both front-end and
                                                          	// back-end connections of your load balancer. For more information, see Configure
                                                          	// Idle Connection Timeout
                                                          	// (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/config-idle-timeout.html)
                                                          	// in the Classic Load Balancers Guide.
                                                          	ConnectionSettings *ConnectionSettings
                                                          
                                                          	// If enabled, the load balancer routes the request traffic evenly across all
                                                          	// instances regardless of the Availability Zones. For more information, see
                                                          	// Configure Cross-Zone Load Balancing
                                                          	// (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-disable-crosszone-lb.html)
                                                          	// in the Classic Load Balancers Guide.
                                                          	CrossZoneLoadBalancing *CrossZoneLoadBalancing
                                                          }

                                                            The attributes for a load balancer.

                                                            type LoadBalancerDescription

                                                            type LoadBalancerDescription struct {
                                                            
                                                            	// The Availability Zones for the load balancer.
                                                            	AvailabilityZones []string
                                                            
                                                            	// Information about your EC2 instances.
                                                            	BackendServerDescriptions []BackendServerDescription
                                                            
                                                            	// The DNS name of the load balancer. For more information, see Configure a Custom
                                                            	// Domain Name
                                                            	// (https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/using-domain-names-with-elb.html)
                                                            	// in the Classic Load Balancers Guide.
                                                            	CanonicalHostedZoneName *string
                                                            
                                                            	// The ID of the Amazon Route 53 hosted zone for the load balancer.
                                                            	CanonicalHostedZoneNameID *string
                                                            
                                                            	// The date and time the load balancer was created.
                                                            	CreatedTime *time.Time
                                                            
                                                            	// The DNS name of the load balancer.
                                                            	DNSName *string
                                                            
                                                            	// Information about the health checks conducted on the load balancer.
                                                            	HealthCheck *HealthCheck
                                                            
                                                            	// The IDs of the instances for the load balancer.
                                                            	Instances []Instance
                                                            
                                                            	// The listeners for the load balancer.
                                                            	ListenerDescriptions []ListenerDescription
                                                            
                                                            	// The name of the load balancer.
                                                            	LoadBalancerName *string
                                                            
                                                            	// The policies defined for the load balancer.
                                                            	Policies *Policies
                                                            
                                                            	// The type of load balancer. Valid only for load balancers in a VPC. If Scheme is
                                                            	// internet-facing, the load balancer has a public DNS name that resolves to a
                                                            	// public IP address. If Scheme is internal, the load balancer has a public DNS
                                                            	// name that resolves to a private IP address.
                                                            	Scheme *string
                                                            
                                                            	// The security groups for the load balancer. Valid only for load balancers in a
                                                            	// VPC.
                                                            	SecurityGroups []string
                                                            
                                                            	// The security group for the load balancer, which you can use as part of your
                                                            	// inbound rules for your registered instances. To only allow traffic from load
                                                            	// balancers, add a security group rule that specifies this source security group
                                                            	// as the inbound source.
                                                            	SourceSecurityGroup *SourceSecurityGroup
                                                            
                                                            	// The IDs of the subnets for the load balancer.
                                                            	Subnets []string
                                                            
                                                            	// The ID of the VPC for the load balancer.
                                                            	VPCId *string
                                                            }

                                                              Information about a load balancer.

                                                              type OperationNotPermittedException

                                                              type OperationNotPermittedException struct {
                                                              	Message *string
                                                              }

                                                                This operation is not allowed.

                                                                func (*OperationNotPermittedException) Error

                                                                func (*OperationNotPermittedException) ErrorCode

                                                                func (e *OperationNotPermittedException) ErrorCode() string

                                                                func (*OperationNotPermittedException) ErrorFault

                                                                func (*OperationNotPermittedException) ErrorMessage

                                                                func (e *OperationNotPermittedException) ErrorMessage() string

                                                                type Policies

                                                                type Policies struct {
                                                                
                                                                	// The stickiness policies created using CreateAppCookieStickinessPolicy.
                                                                	AppCookieStickinessPolicies []AppCookieStickinessPolicy
                                                                
                                                                	// The stickiness policies created using CreateLBCookieStickinessPolicy.
                                                                	LBCookieStickinessPolicies []LBCookieStickinessPolicy
                                                                
                                                                	// The policies other than the stickiness policies.
                                                                	OtherPolicies []string
                                                                }

                                                                  The policies for a load balancer.

                                                                  type PolicyAttribute

                                                                  type PolicyAttribute struct {
                                                                  
                                                                  	// The name of the attribute.
                                                                  	AttributeName *string
                                                                  
                                                                  	// The value of the attribute.
                                                                  	AttributeValue *string
                                                                  }

                                                                    Information about a policy attribute.

                                                                    type PolicyAttributeDescription

                                                                    type PolicyAttributeDescription struct {
                                                                    
                                                                    	// The name of the attribute.
                                                                    	AttributeName *string
                                                                    
                                                                    	// The value of the attribute.
                                                                    	AttributeValue *string
                                                                    }

                                                                      Information about a policy attribute.

                                                                      type PolicyAttributeTypeDescription

                                                                      type PolicyAttributeTypeDescription struct {
                                                                      
                                                                      	// The name of the attribute.
                                                                      	AttributeName *string
                                                                      
                                                                      	// The type of the attribute. For example, Boolean or Integer.
                                                                      	AttributeType *string
                                                                      
                                                                      	// The cardinality of the attribute. Valid values:
                                                                      	//
                                                                      	// * ONE(1) : Single value
                                                                      	// required
                                                                      	//
                                                                      	// * ZERO_OR_ONE(0..1) : Up to one value is allowed
                                                                      	//
                                                                      	// * ZERO_OR_MORE(0..*)
                                                                      	// : Optional. Multiple values are allowed
                                                                      	//
                                                                      	// * ONE_OR_MORE(1..*0) : Required.
                                                                      	// Multiple values are allowed
                                                                      	Cardinality *string
                                                                      
                                                                      	// The default value of the attribute, if applicable.
                                                                      	DefaultValue *string
                                                                      
                                                                      	// A description of the attribute.
                                                                      	Description *string
                                                                      }

                                                                        Information about a policy attribute type.

                                                                        type PolicyDescription

                                                                        type PolicyDescription struct {
                                                                        
                                                                        	// The policy attributes.
                                                                        	PolicyAttributeDescriptions []PolicyAttributeDescription
                                                                        
                                                                        	// The name of the policy.
                                                                        	PolicyName *string
                                                                        
                                                                        	// The name of the policy type.
                                                                        	PolicyTypeName *string
                                                                        }

                                                                          Information about a policy.

                                                                          type PolicyNotFoundException

                                                                          type PolicyNotFoundException struct {
                                                                          	Message *string
                                                                          }

                                                                            One or more of the specified policies do not exist.

                                                                            func (*PolicyNotFoundException) Error

                                                                            func (e *PolicyNotFoundException) Error() string

                                                                            func (*PolicyNotFoundException) ErrorCode

                                                                            func (e *PolicyNotFoundException) ErrorCode() string

                                                                            func (*PolicyNotFoundException) ErrorFault

                                                                            func (e *PolicyNotFoundException) ErrorFault() smithy.ErrorFault

                                                                            func (*PolicyNotFoundException) ErrorMessage

                                                                            func (e *PolicyNotFoundException) ErrorMessage() string

                                                                            type PolicyTypeDescription

                                                                            type PolicyTypeDescription struct {
                                                                            
                                                                            	// A description of the policy type.
                                                                            	Description *string
                                                                            
                                                                            	// The description of the policy attributes associated with the policies defined by
                                                                            	// Elastic Load Balancing.
                                                                            	PolicyAttributeTypeDescriptions []PolicyAttributeTypeDescription
                                                                            
                                                                            	// The name of the policy type.
                                                                            	PolicyTypeName *string
                                                                            }

                                                                              Information about a policy type.

                                                                              type PolicyTypeNotFoundException

                                                                              type PolicyTypeNotFoundException struct {
                                                                              	Message *string
                                                                              }

                                                                                One or more of the specified policy types do not exist.

                                                                                func (*PolicyTypeNotFoundException) Error

                                                                                func (*PolicyTypeNotFoundException) ErrorCode

                                                                                func (e *PolicyTypeNotFoundException) ErrorCode() string

                                                                                func (*PolicyTypeNotFoundException) ErrorFault

                                                                                func (*PolicyTypeNotFoundException) ErrorMessage

                                                                                func (e *PolicyTypeNotFoundException) ErrorMessage() string

                                                                                type SourceSecurityGroup

                                                                                type SourceSecurityGroup struct {
                                                                                
                                                                                	// The name of the security group.
                                                                                	GroupName *string
                                                                                
                                                                                	// The owner of the security group.
                                                                                	OwnerAlias *string
                                                                                }

                                                                                  Information about a source security group.

                                                                                  type SubnetNotFoundException

                                                                                  type SubnetNotFoundException struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    One or more of the specified subnets do not exist.

                                                                                    func (*SubnetNotFoundException) Error

                                                                                    func (e *SubnetNotFoundException) Error() string

                                                                                    func (*SubnetNotFoundException) ErrorCode

                                                                                    func (e *SubnetNotFoundException) ErrorCode() string

                                                                                    func (*SubnetNotFoundException) ErrorFault

                                                                                    func (e *SubnetNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                    func (*SubnetNotFoundException) ErrorMessage

                                                                                    func (e *SubnetNotFoundException) ErrorMessage() string

                                                                                    type Tag

                                                                                    type Tag struct {
                                                                                    
                                                                                    	// The key of the tag.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	Key *string
                                                                                    
                                                                                    	// The value of the tag.
                                                                                    	Value *string
                                                                                    }

                                                                                      Information about a tag.

                                                                                      type TagDescription

                                                                                      type TagDescription struct {
                                                                                      
                                                                                      	// The name of the load balancer.
                                                                                      	LoadBalancerName *string
                                                                                      
                                                                                      	// The tags.
                                                                                      	Tags []Tag
                                                                                      }

                                                                                        The tags associated with a load balancer.

                                                                                        type TagKeyOnly

                                                                                        type TagKeyOnly struct {
                                                                                        
                                                                                        	// The name of the key.
                                                                                        	Key *string
                                                                                        }

                                                                                          The key of a tag.

                                                                                          type TooManyAccessPointsException

                                                                                          type TooManyAccessPointsException struct {
                                                                                          	Message *string
                                                                                          }

                                                                                            The quota for the number of load balancers has been reached.

                                                                                            func (*TooManyAccessPointsException) Error

                                                                                            func (*TooManyAccessPointsException) ErrorCode

                                                                                            func (e *TooManyAccessPointsException) ErrorCode() string

                                                                                            func (*TooManyAccessPointsException) ErrorFault

                                                                                            func (*TooManyAccessPointsException) ErrorMessage

                                                                                            func (e *TooManyAccessPointsException) ErrorMessage() string

                                                                                            type TooManyPoliciesException

                                                                                            type TooManyPoliciesException struct {
                                                                                            	Message *string
                                                                                            }

                                                                                              The quota for the number of policies for this load balancer has been reached.

                                                                                              func (*TooManyPoliciesException) Error

                                                                                              func (e *TooManyPoliciesException) Error() string

                                                                                              func (*TooManyPoliciesException) ErrorCode

                                                                                              func (e *TooManyPoliciesException) ErrorCode() string

                                                                                              func (*TooManyPoliciesException) ErrorFault

                                                                                              func (e *TooManyPoliciesException) ErrorFault() smithy.ErrorFault

                                                                                              func (*TooManyPoliciesException) ErrorMessage

                                                                                              func (e *TooManyPoliciesException) ErrorMessage() string

                                                                                              type TooManyTagsException

                                                                                              type TooManyTagsException struct {
                                                                                              	Message *string
                                                                                              }

                                                                                                The quota for the number of tags that can be assigned to a load balancer has been reached.

                                                                                                func (*TooManyTagsException) Error

                                                                                                func (e *TooManyTagsException) Error() string

                                                                                                func (*TooManyTagsException) ErrorCode

                                                                                                func (e *TooManyTagsException) ErrorCode() string

                                                                                                func (*TooManyTagsException) ErrorFault

                                                                                                func (e *TooManyTagsException) ErrorFault() smithy.ErrorFault

                                                                                                func (*TooManyTagsException) ErrorMessage

                                                                                                func (e *TooManyTagsException) ErrorMessage() string

                                                                                                type UnsupportedProtocolException

                                                                                                type UnsupportedProtocolException struct {
                                                                                                	Message *string
                                                                                                }

                                                                                                  The specified protocol or signature version is not supported.

                                                                                                  func (*UnsupportedProtocolException) Error

                                                                                                  func (*UnsupportedProtocolException) ErrorCode

                                                                                                  func (e *UnsupportedProtocolException) ErrorCode() string

                                                                                                  func (*UnsupportedProtocolException) ErrorFault

                                                                                                  func (*UnsupportedProtocolException) ErrorMessage

                                                                                                  func (e *UnsupportedProtocolException) ErrorMessage() string

                                                                                                  Source Files