Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Accelerator

type Accelerator struct {

	// The Amazon Resource Name (ARN) of the accelerator.
	AcceleratorArn *string

	// The date and time that the accelerator was created.
	CreatedTime *time.Time

	// The Domain Name System (DNS) name that Global Accelerator creates that points to
	// your accelerator's static IP addresses. The naming convention for the DNS name
	// is the following: A lowercase letter a, followed by a 16-bit random hex string,
	// followed by .awsglobalaccelerator.com. For example:
	// a1234567890abcdef.awsglobalaccelerator.com. For more information about the
	// default DNS name, see  Support for DNS Addressing in Global Accelerator
	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/about-accelerators.html#about-accelerators.dns-addressing)
	// in the AWS Global Accelerator Developer Guide.
	DnsName *string

	// Indicates whether the accelerator is enabled. The value is true or false. The
	// default value is true. If the value is set to true, the accelerator cannot be
	// deleted. If set to false, accelerator can be deleted.
	Enabled *bool

	// The value for the address type must be IPv4.
	IpAddressType IpAddressType

	// The static IP addresses that Global Accelerator associates with the accelerator.
	IpSets []IpSet

	// The date and time that the accelerator was last modified.
	LastModifiedTime *time.Time

	// The name of the accelerator. The name must contain only alphanumeric characters
	// or hyphens (-), and must not begin or end with a hyphen.
	Name *string

	// Describes the deployment status of the accelerator.
	Status AcceleratorStatus
}

    An accelerator is a complex type that includes one or more listeners that process inbound connections and then direct traffic to one or more endpoint groups, each of which includes endpoints, such as load balancers.

    type AcceleratorAttributes

    type AcceleratorAttributes struct {
    
    	// Indicates whether flow logs are enabled. The default value is false. If the
    	// value is true, FlowLogsS3Bucket and FlowLogsS3Prefix must be specified. For more
    	// information, see Flow Logs
    	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/monitoring-global-accelerator.flow-logs.html)
    	// in the AWS Global Accelerator Developer Guide.
    	FlowLogsEnabled *bool
    
    	// The name of the Amazon S3 bucket for the flow logs. Attribute is required if
    	// FlowLogsEnabled is true. The bucket must exist and have a bucket policy that
    	// grants AWS Global Accelerator permission to write to the bucket.
    	FlowLogsS3Bucket *string
    
    	// The prefix for the location in the Amazon S3 bucket for the flow logs. Attribute
    	// is required if FlowLogsEnabled is true. If you don’t specify a prefix, the flow
    	// logs are stored in the root of the bucket. If you specify slash (/) for the S3
    	// bucket prefix, the log file bucket folder structure will include a double slash
    	// (//), like the following: s3-bucket_name//AWSLogs/aws_account_id
    	FlowLogsS3Prefix *string
    }

      Attributes of an accelerator.

      type AcceleratorNotDisabledException

      type AcceleratorNotDisabledException struct {
      	Message *string
      }

        The accelerator that you specified could not be disabled.

        func (*AcceleratorNotDisabledException) Error

        func (*AcceleratorNotDisabledException) ErrorCode

        func (e *AcceleratorNotDisabledException) ErrorCode() string

        func (*AcceleratorNotDisabledException) ErrorFault

        func (*AcceleratorNotDisabledException) ErrorMessage

        func (e *AcceleratorNotDisabledException) ErrorMessage() string

        type AcceleratorNotFoundException

        type AcceleratorNotFoundException struct {
        	Message *string
        }

          The accelerator that you specified doesn't exist.

          func (*AcceleratorNotFoundException) Error

          func (*AcceleratorNotFoundException) ErrorCode

          func (e *AcceleratorNotFoundException) ErrorCode() string

          func (*AcceleratorNotFoundException) ErrorFault

          func (*AcceleratorNotFoundException) ErrorMessage

          func (e *AcceleratorNotFoundException) ErrorMessage() string

          type AcceleratorStatus

          type AcceleratorStatus string
          const (
          	AcceleratorStatusDeployed   AcceleratorStatus = "DEPLOYED"
          	AcceleratorStatusInProgress AcceleratorStatus = "IN_PROGRESS"
          )

            Enum values for AcceleratorStatus

            func (AcceleratorStatus) Values

              Values returns all known values for AcceleratorStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

              type AccessDeniedException

              type AccessDeniedException struct {
              	Message *string
              }

                You don't have access permission.

                func (*AccessDeniedException) Error

                func (e *AccessDeniedException) Error() string

                func (*AccessDeniedException) ErrorCode

                func (e *AccessDeniedException) ErrorCode() string

                func (*AccessDeniedException) ErrorFault

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

                func (*AccessDeniedException) ErrorMessage

                func (e *AccessDeniedException) ErrorMessage() string

                type AssociatedEndpointGroupFoundException

                type AssociatedEndpointGroupFoundException struct {
                	Message *string
                }

                  The listener that you specified has an endpoint group associated with it. You must remove all dependent resources from a listener before you can delete it.

                  func (*AssociatedEndpointGroupFoundException) Error

                  func (*AssociatedEndpointGroupFoundException) ErrorCode

                  func (*AssociatedEndpointGroupFoundException) ErrorFault

                  func (*AssociatedEndpointGroupFoundException) ErrorMessage

                  type AssociatedListenerFoundException

                  type AssociatedListenerFoundException struct {
                  	Message *string
                  }

                    The accelerator that you specified has a listener associated with it. You must remove all dependent resources from an accelerator before you can delete it.

                    func (*AssociatedListenerFoundException) Error

                    func (*AssociatedListenerFoundException) ErrorCode

                    func (*AssociatedListenerFoundException) ErrorFault

                    func (*AssociatedListenerFoundException) ErrorMessage

                    func (e *AssociatedListenerFoundException) ErrorMessage() string

                    type ByoipCidr

                    type ByoipCidr struct {
                    
                    	// The address range, in CIDR notation.
                    	Cidr *string
                    
                    	// A history of status changes for an IP address range that you bring to AWS Global
                    	// Accelerator through bring your own IP address (BYOIP).
                    	Events []ByoipCidrEvent
                    
                    	// The state of the address pool.
                    	State ByoipCidrState
                    }

                      Information about an IP address range that is provisioned for use with your AWS resources through bring your own IP address (BYOIP). The following describes each BYOIP State that your IP address range can be in.

                      * PENDING_PROVISIONING — You’ve submitted a request to provision an IP address range but it is not yet provisioned with AWS Global Accelerator.

                      * READY — The address range is provisioned with AWS Global Accelerator and can be advertised.

                      * PENDING_ADVERTISING — You’ve submitted a request for AWS Global Accelerator to advertise an address range but it is not yet being advertised.

                      * ADVERTISING — The address range is being advertised by AWS Global Accelerator.

                      * PENDING_WITHDRAWING — You’ve submitted a request to withdraw an address range from being advertised but it is still being advertised by AWS Global Accelerator.

                      * PENDING_DEPROVISIONING — You’ve submitted a request to deprovision an address range from AWS Global Accelerator but it is still provisioned.

                      * DEPROVISIONED — The address range is deprovisioned from AWS Global Accelerator.

                      * FAILED_PROVISION — The request to provision the address range from AWS Global Accelerator was not successful. Please make sure that you provide all of the correct information, and try again. If the request fails a second time, contact AWS support.

                      * FAILED_ADVERTISING — The request for AWS Global Accelerator to advertise the address range was not successful. Please make sure that you provide all of the correct information, and try again. If the request fails a second time, contact AWS support.

                      * FAILED_WITHDRAW — The request to withdraw the address range from advertising by AWS Global Accelerator was not successful. Please make sure that you provide all of the correct information, and try again. If the request fails a second time, contact AWS support.

                      * FAILED_DEPROVISION — The request to deprovision the address range from AWS Global Accelerator was not successful. Please make sure that you provide all of the correct information, and try again. If the request fails a second time, contact AWS support.

                      type ByoipCidrEvent

                      type ByoipCidrEvent struct {
                      
                      	// A string that contains an Event message describing changes that you make in the
                      	// status of an IP address range that you bring to AWS Global Accelerator through
                      	// bring your own IP address (BYOIP).
                      	Message *string
                      
                      	// A timestamp when you make a status change for an IP address range that you bring
                      	// to AWS Global Accelerator through bring your own IP address (BYOIP).
                      	Timestamp *time.Time
                      }

                        A complex type that contains a Message and a Timestamp value for changes that you make in the status an IP address range that you bring to AWS Global Accelerator through bring your own IP address (BYOIP).

                        type ByoipCidrNotFoundException

                        type ByoipCidrNotFoundException struct {
                        	Message *string
                        }

                          The CIDR that you specified was not found or is incorrect.

                          func (*ByoipCidrNotFoundException) Error

                          func (*ByoipCidrNotFoundException) ErrorCode

                          func (e *ByoipCidrNotFoundException) ErrorCode() string

                          func (*ByoipCidrNotFoundException) ErrorFault

                          func (*ByoipCidrNotFoundException) ErrorMessage

                          func (e *ByoipCidrNotFoundException) ErrorMessage() string

                          type ByoipCidrState

                          type ByoipCidrState string
                          const (
                          	ByoipCidrStatePendingProvisioning   ByoipCidrState = "PENDING_PROVISIONING"
                          	ByoipCidrStateReady                 ByoipCidrState = "READY"
                          	ByoipCidrStatePendingAdvertising    ByoipCidrState = "PENDING_ADVERTISING"
                          	ByoipCidrStateAdvertising           ByoipCidrState = "ADVERTISING"
                          	ByoipCidrStatePendingWithdrawing    ByoipCidrState = "PENDING_WITHDRAWING"
                          	ByoipCidrStatePendingDeprovisioning ByoipCidrState = "PENDING_DEPROVISIONING"
                          	ByoipCidrStateDeprovisioned         ByoipCidrState = "DEPROVISIONED"
                          	ByoipCidrStateFailedProvision       ByoipCidrState = "FAILED_PROVISION"
                          	ByoipCidrStateFailedAdvertising     ByoipCidrState = "FAILED_ADVERTISING"
                          	ByoipCidrStateFailedWithdraw        ByoipCidrState = "FAILED_WITHDRAW"
                          	ByoipCidrStateFailedDeprovision     ByoipCidrState = "FAILED_DEPROVISION"
                          )

                            Enum values for ByoipCidrState

                            func (ByoipCidrState) Values

                            func (ByoipCidrState) Values() []ByoipCidrState

                              Values returns all known values for ByoipCidrState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                              type CidrAuthorizationContext

                              type CidrAuthorizationContext struct {
                              
                              	// The plain-text authorization message for the prefix and account.
                              	//
                              	// This member is required.
                              	Message *string
                              
                              	// The signed authorization message for the prefix and account.
                              	//
                              	// This member is required.
                              	Signature *string
                              }

                                Provides authorization for Amazon to bring a specific IP address range to a specific AWS account using bring your own IP addresses (BYOIP). For more information, see Bring Your Own IP Addresses (BYOIP) (https://docs.aws.amazon.com/global-accelerator/latest/dg/using-byoip.html) in the AWS Global Accelerator Developer Guide.

                                type ClientAffinity

                                type ClientAffinity string
                                const (
                                	ClientAffinityNone     ClientAffinity = "NONE"
                                	ClientAffinitySourceIp ClientAffinity = "SOURCE_IP"
                                )

                                  Enum values for ClientAffinity

                                  func (ClientAffinity) Values

                                  func (ClientAffinity) Values() []ClientAffinity

                                    Values returns all known values for ClientAffinity. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                    type ConflictException

                                    type ConflictException struct {
                                    	Message *string
                                    }

                                      You can't use both of those options.

                                      func (*ConflictException) Error

                                      func (e *ConflictException) Error() string

                                      func (*ConflictException) ErrorCode

                                      func (e *ConflictException) ErrorCode() string

                                      func (*ConflictException) ErrorFault

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

                                      func (*ConflictException) ErrorMessage

                                      func (e *ConflictException) ErrorMessage() string

                                      type CustomRoutingAccelerator

                                      type CustomRoutingAccelerator struct {
                                      
                                      	// The Amazon Resource Name (ARN) of the custom routing accelerator.
                                      	AcceleratorArn *string
                                      
                                      	// The date and time that the accelerator was created.
                                      	CreatedTime *time.Time
                                      
                                      	// The Domain Name System (DNS) name that Global Accelerator creates that points to
                                      	// your accelerator's static IP addresses. The naming convention for the DNS name
                                      	// is the following: A lowercase letter a, followed by a 16-bit random hex string,
                                      	// followed by .awsglobalaccelerator.com. For example:
                                      	// a1234567890abcdef.awsglobalaccelerator.com. For more information about the
                                      	// default DNS name, see  Support for DNS Addressing in Global Accelerator
                                      	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/about-accelerators.html#about-accelerators.dns-addressing)
                                      	// in the AWS Global Accelerator Developer Guide.
                                      	DnsName *string
                                      
                                      	// Indicates whether the accelerator is enabled. The value is true or false. The
                                      	// default value is true. If the value is set to true, the accelerator cannot be
                                      	// deleted. If set to false, accelerator can be deleted.
                                      	Enabled *bool
                                      
                                      	// The value for the address type must be IPv4.
                                      	IpAddressType IpAddressType
                                      
                                      	// The static IP addresses that Global Accelerator associates with the accelerator.
                                      	IpSets []IpSet
                                      
                                      	// The date and time that the accelerator was last modified.
                                      	LastModifiedTime *time.Time
                                      
                                      	// The name of the accelerator. The name must contain only alphanumeric characters
                                      	// or hyphens (-), and must not begin or end with a hyphen.
                                      	Name *string
                                      
                                      	// Describes the deployment status of the accelerator.
                                      	Status CustomRoutingAcceleratorStatus
                                      }

                                        Attributes of a custom routing accelerator.

                                        type CustomRoutingAcceleratorAttributes

                                        type CustomRoutingAcceleratorAttributes struct {
                                        
                                        	// Indicates whether flow logs are enabled. The default value is false. If the
                                        	// value is true, FlowLogsS3Bucket and FlowLogsS3Prefix must be specified. For more
                                        	// information, see Flow Logs
                                        	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/monitoring-global-accelerator.flow-logs.html)
                                        	// in the AWS Global Accelerator Developer Guide.
                                        	FlowLogsEnabled *bool
                                        
                                        	// The name of the Amazon S3 bucket for the flow logs. Attribute is required if
                                        	// FlowLogsEnabled is true. The bucket must exist and have a bucket policy that
                                        	// grants AWS Global Accelerator permission to write to the bucket.
                                        	FlowLogsS3Bucket *string
                                        
                                        	// The prefix for the location in the Amazon S3 bucket for the flow logs. Attribute
                                        	// is required if FlowLogsEnabled is true. If you don’t specify a prefix, the flow
                                        	// logs are stored in the root of the bucket. If you specify slash (/) for the S3
                                        	// bucket prefix, the log file bucket folder structure will include a double slash
                                        	// (//), like the following: DOC-EXAMPLE-BUCKET//AWSLogs/aws_account_id
                                        	FlowLogsS3Prefix *string
                                        }

                                          Attributes of a custom routing accelerator.

                                          type CustomRoutingAcceleratorStatus

                                          type CustomRoutingAcceleratorStatus string
                                          const (
                                          	CustomRoutingAcceleratorStatusDeployed   CustomRoutingAcceleratorStatus = "DEPLOYED"
                                          	CustomRoutingAcceleratorStatusInProgress CustomRoutingAcceleratorStatus = "IN_PROGRESS"
                                          )

                                            Enum values for CustomRoutingAcceleratorStatus

                                            func (CustomRoutingAcceleratorStatus) Values

                                              Values returns all known values for CustomRoutingAcceleratorStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                              type CustomRoutingDestinationConfiguration

                                              type CustomRoutingDestinationConfiguration struct {
                                              
                                              	// The first port, inclusive, in the range of ports for the endpoint group that is
                                              	// associated with a custom routing accelerator.
                                              	//
                                              	// This member is required.
                                              	FromPort *int32
                                              
                                              	// The protocol for the endpoint group that is associated with a custom routing
                                              	// accelerator. The protocol can be either TCP or UDP.
                                              	//
                                              	// This member is required.
                                              	Protocols []CustomRoutingProtocol
                                              
                                              	// The last port, inclusive, in the range of ports for the endpoint group that is
                                              	// associated with a custom routing accelerator.
                                              	//
                                              	// This member is required.
                                              	ToPort *int32
                                              }

                                                For a custom routing accelerator, sets the port range and protocol for all endpoints (virtual private cloud subnets) in an endpoint group to accept client traffic on.

                                                type CustomRoutingDestinationDescription

                                                type CustomRoutingDestinationDescription struct {
                                                
                                                	// The first port, inclusive, in the range of ports for the endpoint group that is
                                                	// associated with a custom routing accelerator.
                                                	FromPort *int32
                                                
                                                	// The protocol for the endpoint group that is associated with a custom routing
                                                	// accelerator. The protocol can be either TCP or UDP.
                                                	Protocols []Protocol
                                                
                                                	// The last port, inclusive, in the range of ports for the endpoint group that is
                                                	// associated with a custom routing accelerator.
                                                	ToPort *int32
                                                }

                                                  For a custom routing accelerator, describes the port range and protocol for all endpoints (virtual private cloud subnets) in an endpoint group to accept client traffic on.

                                                  type CustomRoutingDestinationTrafficState

                                                  type CustomRoutingDestinationTrafficState string
                                                  const (
                                                  	CustomRoutingDestinationTrafficStateAllow CustomRoutingDestinationTrafficState = "ALLOW"
                                                  	CustomRoutingDestinationTrafficStateDeny  CustomRoutingDestinationTrafficState = "DENY"
                                                  )

                                                    Enum values for CustomRoutingDestinationTrafficState

                                                    func (CustomRoutingDestinationTrafficState) Values

                                                      Values returns all known values for CustomRoutingDestinationTrafficState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                      type CustomRoutingEndpointConfiguration

                                                      type CustomRoutingEndpointConfiguration struct {
                                                      
                                                      	// An ID for the endpoint. For custom routing accelerators, this is the virtual
                                                      	// private cloud (VPC) subnet ID.
                                                      	EndpointId *string
                                                      }

                                                        The list of endpoint objects. For custom routing, this is a list of virtual private cloud (VPC) subnet IDs.

                                                        type CustomRoutingEndpointDescription

                                                        type CustomRoutingEndpointDescription struct {
                                                        
                                                        	// An ID for the endpoint. For custom routing accelerators, this is the virtual
                                                        	// private cloud (VPC) subnet ID.
                                                        	EndpointId *string
                                                        }

                                                          A complex type for an endpoint for a custom routing accelerator. Each endpoint group can include one or more endpoints, which are virtual private cloud (VPC) subnets.

                                                          type CustomRoutingEndpointGroup

                                                          type CustomRoutingEndpointGroup struct {
                                                          
                                                          	// For a custom routing accelerator, describes the port range and protocol for all
                                                          	// endpoints (virtual private cloud subnets) in an endpoint group to accept client
                                                          	// traffic on.
                                                          	DestinationDescriptions []CustomRoutingDestinationDescription
                                                          
                                                          	// For a custom routing accelerator, describes the endpoints (virtual private cloud
                                                          	// subnets) in an endpoint group to accept client traffic on.
                                                          	EndpointDescriptions []CustomRoutingEndpointDescription
                                                          
                                                          	// The Amazon Resource Name (ARN) of the endpoint group.
                                                          	EndpointGroupArn *string
                                                          
                                                          	// The AWS Region where the endpoint group is located.
                                                          	EndpointGroupRegion *string
                                                          }

                                                            A complex type for the endpoint group for a custom routing accelerator. An AWS Region can have only one endpoint group for a specific listener.

                                                            type CustomRoutingListener

                                                            type CustomRoutingListener struct {
                                                            
                                                            	// The Amazon Resource Name (ARN) of the listener.
                                                            	ListenerArn *string
                                                            
                                                            	// The port range to support for connections from clients to your accelerator.
                                                            	// Separately, you set port ranges for endpoints. For more information, see About
                                                            	// endpoints for custom routing accelerators
                                                            	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/about-custom-routing-endpoints.html).
                                                            	PortRanges []PortRange
                                                            }

                                                              A complex type for a listener for a custom routing accelerator.

                                                              type CustomRoutingProtocol

                                                              type CustomRoutingProtocol string
                                                              const (
                                                              	CustomRoutingProtocolTcp CustomRoutingProtocol = "TCP"
                                                              	CustomRoutingProtocolUdp CustomRoutingProtocol = "UDP"
                                                              )

                                                                Enum values for CustomRoutingProtocol

                                                                func (CustomRoutingProtocol) Values

                                                                  Values returns all known values for CustomRoutingProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                  type DestinationPortMapping

                                                                  type DestinationPortMapping struct {
                                                                  
                                                                  	// The Amazon Resource Name (ARN) of the custom routing accelerator that you have
                                                                  	// port mappings for.
                                                                  	AcceleratorArn *string
                                                                  
                                                                  	// The IP address/port combinations (sockets) that map to a given destination
                                                                  	// socket address.
                                                                  	AcceleratorSocketAddresses []SocketAddress
                                                                  
                                                                  	// The endpoint IP address/port combination for traffic received on the accelerator
                                                                  	// socket address.
                                                                  	DestinationSocketAddress *SocketAddress
                                                                  
                                                                  	// Indicates whether or not a port mapping destination can receive traffic. The
                                                                  	// value is either ALLOW, if traffic is allowed to the destination, or DENY, if
                                                                  	// traffic is not allowed to the destination.
                                                                  	DestinationTrafficState CustomRoutingDestinationTrafficState
                                                                  
                                                                  	// The Amazon Resource Name (ARN) of the endpoint group.
                                                                  	EndpointGroupArn *string
                                                                  
                                                                  	// The AWS Region for the endpoint group.
                                                                  	EndpointGroupRegion *string
                                                                  
                                                                  	// The ID for the virtual private cloud (VPC) subnet.
                                                                  	EndpointId *string
                                                                  
                                                                  	// The IP address type, which must be IPv4.
                                                                  	IpAddressType IpAddressType
                                                                  }

                                                                    The port mappings for a specified endpoint IP address (destination).

                                                                    type EndpointAlreadyExistsException

                                                                    type EndpointAlreadyExistsException struct {
                                                                    	Message *string
                                                                    }

                                                                      The endpoint that you specified doesn't exist.

                                                                      func (*EndpointAlreadyExistsException) Error

                                                                      func (*EndpointAlreadyExistsException) ErrorCode

                                                                      func (e *EndpointAlreadyExistsException) ErrorCode() string

                                                                      func (*EndpointAlreadyExistsException) ErrorFault

                                                                      func (*EndpointAlreadyExistsException) ErrorMessage

                                                                      func (e *EndpointAlreadyExistsException) ErrorMessage() string

                                                                      type EndpointConfiguration

                                                                      type EndpointConfiguration struct {
                                                                      
                                                                      	// Indicates whether client IP address preservation is enabled for an Application
                                                                      	// Load Balancer endpoint. The value is true or false. The default value is true
                                                                      	// for new accelerators. If the value is set to true, the client's IP address is
                                                                      	// preserved in the X-Forwarded-For request header as traffic travels to
                                                                      	// applications on the Application Load Balancer endpoint fronted by the
                                                                      	// accelerator. For more information, see  Preserve Client IP Addresses in AWS
                                                                      	// Global Accelerator
                                                                      	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/preserve-client-ip-address.html)
                                                                      	// in the AWS Global Accelerator Developer Guide.
                                                                      	ClientIPPreservationEnabled *bool
                                                                      
                                                                      	// An ID for the endpoint. If the endpoint is a Network Load Balancer or
                                                                      	// Application Load Balancer, this is the Amazon Resource Name (ARN) of the
                                                                      	// resource. If the endpoint is an Elastic IP address, this is the Elastic IP
                                                                      	// address allocation ID. For Amazon EC2 instances, this is the EC2 instance ID. A
                                                                      	// resource must be valid and active when you add it as an endpoint. An Application
                                                                      	// Load Balancer can be either internal or internet-facing.
                                                                      	EndpointId *string
                                                                      
                                                                      	// The weight associated with the endpoint. When you add weights to endpoints, you
                                                                      	// configure AWS Global Accelerator to route traffic based on proportions that you
                                                                      	// specify. For example, you might specify endpoint weights of 4, 5, 5, and 6
                                                                      	// (sum=20). The result is that 4/20 of your traffic, on average, is routed to the
                                                                      	// first endpoint, 5/20 is routed both to the second and third endpoints, and 6/20
                                                                      	// is routed to the last endpoint. For more information, see Endpoint Weights
                                                                      	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/about-endpoints-endpoint-weights.html)
                                                                      	// in the AWS Global Accelerator Developer Guide.
                                                                      	Weight *int32
                                                                      }

                                                                        A complex type for endpoints. A resource must be valid and active when you add it as an endpoint.

                                                                        type EndpointDescription

                                                                        type EndpointDescription struct {
                                                                        
                                                                        	// Indicates whether client IP address preservation is enabled for an Application
                                                                        	// Load Balancer endpoint. The value is true or false. The default value is true
                                                                        	// for new accelerators. If the value is set to true, the client's IP address is
                                                                        	// preserved in the X-Forwarded-For request header as traffic travels to
                                                                        	// applications on the Application Load Balancer endpoint fronted by the
                                                                        	// accelerator. For more information, see  Viewing Client IP Addresses in AWS
                                                                        	// Global Accelerator
                                                                        	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/introduction-how-it-works-client-ip.html)
                                                                        	// in the AWS Global Accelerator Developer Guide.
                                                                        	ClientIPPreservationEnabled *bool
                                                                        
                                                                        	// An ID for the endpoint. If the endpoint is a Network Load Balancer or
                                                                        	// Application Load Balancer, this is the Amazon Resource Name (ARN) of the
                                                                        	// resource. If the endpoint is an Elastic IP address, this is the Elastic IP
                                                                        	// address allocation ID. For Amazon EC2 instances, this is the EC2 instance ID. An
                                                                        	// Application Load Balancer can be either internal or internet-facing.
                                                                        	EndpointId *string
                                                                        
                                                                        	// Returns a null result.
                                                                        	HealthReason *string
                                                                        
                                                                        	// The health status of the endpoint.
                                                                        	HealthState HealthState
                                                                        
                                                                        	// The weight associated with the endpoint. When you add weights to endpoints, you
                                                                        	// configure AWS Global Accelerator to route traffic based on proportions that you
                                                                        	// specify. For example, you might specify endpoint weights of 4, 5, 5, and 6
                                                                        	// (sum=20). The result is that 4/20 of your traffic, on average, is routed to the
                                                                        	// first endpoint, 5/20 is routed both to the second and third endpoints, and 6/20
                                                                        	// is routed to the last endpoint. For more information, see Endpoint Weights
                                                                        	// (https://docs.aws.amazon.com/global-accelerator/latest/dg/about-endpoints-endpoint-weights.html)
                                                                        	// in the AWS Global Accelerator Developer Guide.
                                                                        	Weight *int32
                                                                        }

                                                                          A complex type for an endpoint. Each endpoint group can include one or more endpoints, such as load balancers.

                                                                          type EndpointGroup

                                                                          type EndpointGroup struct {
                                                                          
                                                                          	// The list of endpoint objects.
                                                                          	EndpointDescriptions []EndpointDescription
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the endpoint group.
                                                                          	EndpointGroupArn *string
                                                                          
                                                                          	// The AWS Region where the endpoint group is located.
                                                                          	EndpointGroupRegion *string
                                                                          
                                                                          	// The time—10 seconds or 30 seconds—between health checks for each endpoint. The
                                                                          	// default value is 30.
                                                                          	HealthCheckIntervalSeconds *int32
                                                                          
                                                                          	// If the protocol is HTTP/S, then this value provides the ping path that Global
                                                                          	// Accelerator uses for the destination on the endpoints for health checks. The
                                                                          	// default is slash (/).
                                                                          	HealthCheckPath *string
                                                                          
                                                                          	// The port that Global Accelerator uses to perform health checks on endpoints that
                                                                          	// are part of this endpoint group. The default port is the port for the listener
                                                                          	// that this endpoint group is associated with. If the listener port is a list,
                                                                          	// Global Accelerator uses the first specified port in the list of ports.
                                                                          	HealthCheckPort *int32
                                                                          
                                                                          	// The protocol that Global Accelerator uses to perform health checks on endpoints
                                                                          	// that are part of this endpoint group. The default value is TCP.
                                                                          	HealthCheckProtocol HealthCheckProtocol
                                                                          
                                                                          	// Allows you to override the destination ports used to route traffic to an
                                                                          	// endpoint. Using a port override lets you to map a list of external destination
                                                                          	// ports (that your users send traffic to) to a list of internal destination ports
                                                                          	// that you want an application endpoint to receive traffic on.
                                                                          	PortOverrides []PortOverride
                                                                          
                                                                          	// The number of consecutive health checks required to set the state of a healthy
                                                                          	// endpoint to unhealthy, or to set an unhealthy endpoint to healthy. The default
                                                                          	// value is 3.
                                                                          	ThresholdCount *int32
                                                                          
                                                                          	// The percentage of traffic to send to an AWS Region. Additional traffic is
                                                                          	// distributed to other endpoint groups for this listener. Use this action to
                                                                          	// increase (dial up) or decrease (dial down) traffic to a specific Region. The
                                                                          	// percentage is applied to the traffic that would otherwise have been routed to
                                                                          	// the Region based on optimal routing. The default value is 100.
                                                                          	TrafficDialPercentage *float32
                                                                          }

                                                                            A complex type for the endpoint group. An AWS Region can have only one endpoint group for a specific listener.

                                                                            type EndpointGroupAlreadyExistsException

                                                                            type EndpointGroupAlreadyExistsException struct {
                                                                            	Message *string
                                                                            }

                                                                              The endpoint group that you specified already exists.

                                                                              func (*EndpointGroupAlreadyExistsException) Error

                                                                              func (*EndpointGroupAlreadyExistsException) ErrorCode

                                                                              func (*EndpointGroupAlreadyExistsException) ErrorFault

                                                                              func (*EndpointGroupAlreadyExistsException) ErrorMessage

                                                                              func (e *EndpointGroupAlreadyExistsException) ErrorMessage() string

                                                                              type EndpointGroupNotFoundException

                                                                              type EndpointGroupNotFoundException struct {
                                                                              	Message *string
                                                                              }

                                                                                The endpoint group that you specified doesn't exist.

                                                                                func (*EndpointGroupNotFoundException) Error

                                                                                func (*EndpointGroupNotFoundException) ErrorCode

                                                                                func (e *EndpointGroupNotFoundException) ErrorCode() string

                                                                                func (*EndpointGroupNotFoundException) ErrorFault

                                                                                func (*EndpointGroupNotFoundException) ErrorMessage

                                                                                func (e *EndpointGroupNotFoundException) ErrorMessage() string

                                                                                type EndpointNotFoundException

                                                                                type EndpointNotFoundException struct {
                                                                                	Message *string
                                                                                }

                                                                                  The endpoint that you specified doesn't exist.

                                                                                  func (*EndpointNotFoundException) Error

                                                                                  func (e *EndpointNotFoundException) Error() string

                                                                                  func (*EndpointNotFoundException) ErrorCode

                                                                                  func (e *EndpointNotFoundException) ErrorCode() string

                                                                                  func (*EndpointNotFoundException) ErrorFault

                                                                                  func (*EndpointNotFoundException) ErrorMessage

                                                                                  func (e *EndpointNotFoundException) ErrorMessage() string

                                                                                  type HealthCheckProtocol

                                                                                  type HealthCheckProtocol string
                                                                                  const (
                                                                                  	HealthCheckProtocolTcp   HealthCheckProtocol = "TCP"
                                                                                  	HealthCheckProtocolHttp  HealthCheckProtocol = "HTTP"
                                                                                  	HealthCheckProtocolHttps HealthCheckProtocol = "HTTPS"
                                                                                  )

                                                                                    Enum values for HealthCheckProtocol

                                                                                    func (HealthCheckProtocol) Values

                                                                                      Values returns all known values for HealthCheckProtocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                      type HealthState

                                                                                      type HealthState string
                                                                                      const (
                                                                                      	HealthStateInitial   HealthState = "INITIAL"
                                                                                      	HealthStateHealthy   HealthState = "HEALTHY"
                                                                                      	HealthStateUnhealthy HealthState = "UNHEALTHY"
                                                                                      )

                                                                                        Enum values for HealthState

                                                                                        func (HealthState) Values

                                                                                        func (HealthState) Values() []HealthState

                                                                                          Values returns all known values for HealthState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                          type IncorrectCidrStateException

                                                                                          type IncorrectCidrStateException struct {
                                                                                          	Message *string
                                                                                          }

                                                                                            The CIDR that you specified is not valid for this action. For example, the state of the CIDR might be incorrect for this action.

                                                                                            func (*IncorrectCidrStateException) Error

                                                                                            func (*IncorrectCidrStateException) ErrorCode

                                                                                            func (e *IncorrectCidrStateException) ErrorCode() string

                                                                                            func (*IncorrectCidrStateException) ErrorFault

                                                                                            func (*IncorrectCidrStateException) ErrorMessage

                                                                                            func (e *IncorrectCidrStateException) ErrorMessage() string

                                                                                            type InternalServiceErrorException

                                                                                            type InternalServiceErrorException struct {
                                                                                            	Message *string
                                                                                            }

                                                                                              There was an internal error for AWS Global Accelerator.

                                                                                              func (*InternalServiceErrorException) Error

                                                                                              func (*InternalServiceErrorException) ErrorCode

                                                                                              func (e *InternalServiceErrorException) ErrorCode() string

                                                                                              func (*InternalServiceErrorException) ErrorFault

                                                                                              func (*InternalServiceErrorException) ErrorMessage

                                                                                              func (e *InternalServiceErrorException) ErrorMessage() string

                                                                                              type InvalidArgumentException

                                                                                              type InvalidArgumentException struct {
                                                                                              	Message *string
                                                                                              }

                                                                                                An argument that you specified is invalid.

                                                                                                func (*InvalidArgumentException) Error

                                                                                                func (e *InvalidArgumentException) Error() string

                                                                                                func (*InvalidArgumentException) ErrorCode

                                                                                                func (e *InvalidArgumentException) ErrorCode() string

                                                                                                func (*InvalidArgumentException) ErrorFault

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

                                                                                                func (*InvalidArgumentException) ErrorMessage

                                                                                                func (e *InvalidArgumentException) ErrorMessage() string

                                                                                                type InvalidNextTokenException

                                                                                                type InvalidNextTokenException struct {
                                                                                                	Message *string
                                                                                                }

                                                                                                  There isn't another item to return.

                                                                                                  func (*InvalidNextTokenException) Error

                                                                                                  func (e *InvalidNextTokenException) Error() string

                                                                                                  func (*InvalidNextTokenException) ErrorCode

                                                                                                  func (e *InvalidNextTokenException) ErrorCode() string

                                                                                                  func (*InvalidNextTokenException) ErrorFault

                                                                                                  func (*InvalidNextTokenException) ErrorMessage

                                                                                                  func (e *InvalidNextTokenException) ErrorMessage() string

                                                                                                  type InvalidPortRangeException

                                                                                                  type InvalidPortRangeException struct {
                                                                                                  	Message *string
                                                                                                  }

                                                                                                    The port numbers that you specified are not valid numbers or are not unique for this accelerator.

                                                                                                    func (*InvalidPortRangeException) Error

                                                                                                    func (e *InvalidPortRangeException) Error() string

                                                                                                    func (*InvalidPortRangeException) ErrorCode

                                                                                                    func (e *InvalidPortRangeException) ErrorCode() string

                                                                                                    func (*InvalidPortRangeException) ErrorFault

                                                                                                    func (*InvalidPortRangeException) ErrorMessage

                                                                                                    func (e *InvalidPortRangeException) ErrorMessage() string

                                                                                                    type IpAddressType

                                                                                                    type IpAddressType string
                                                                                                    const (
                                                                                                    	IpAddressTypeIpv4 IpAddressType = "IPV4"
                                                                                                    )

                                                                                                      Enum values for IpAddressType

                                                                                                      func (IpAddressType) Values

                                                                                                      func (IpAddressType) Values() []IpAddressType

                                                                                                        Values returns all known values for IpAddressType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                        type IpSet

                                                                                                        type IpSet struct {
                                                                                                        
                                                                                                        	// The array of IP addresses in the IP address set. An IP address set can have a
                                                                                                        	// maximum of two IP addresses.
                                                                                                        	IpAddresses []string
                                                                                                        
                                                                                                        	// The types of IP addresses included in this IP set.
                                                                                                        	IpFamily *string
                                                                                                        }

                                                                                                          A complex type for the set of IP addresses for an accelerator.

                                                                                                          type LimitExceededException

                                                                                                          type LimitExceededException struct {
                                                                                                          	Message *string
                                                                                                          }

                                                                                                            Processing your request would cause you to exceed an AWS Global Accelerator limit.

                                                                                                            func (*LimitExceededException) Error

                                                                                                            func (e *LimitExceededException) Error() string

                                                                                                            func (*LimitExceededException) ErrorCode

                                                                                                            func (e *LimitExceededException) ErrorCode() string

                                                                                                            func (*LimitExceededException) ErrorFault

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

                                                                                                            func (*LimitExceededException) ErrorMessage

                                                                                                            func (e *LimitExceededException) ErrorMessage() string

                                                                                                            type Listener

                                                                                                            type Listener struct {
                                                                                                            
                                                                                                            	// Client affinity lets you direct all requests from a user to the same endpoint,
                                                                                                            	// if you have stateful applications, regardless of the port and protocol of the
                                                                                                            	// client request. Client affinity gives you control over whether to always route
                                                                                                            	// each client to the same specific endpoint. AWS Global Accelerator uses a
                                                                                                            	// consistent-flow hashing algorithm to choose the optimal endpoint for a
                                                                                                            	// connection. If client affinity is NONE, Global Accelerator uses the "five-tuple"
                                                                                                            	// (5-tuple) properties—source IP address, source port, destination IP address,
                                                                                                            	// destination port, and protocol—to select the hash value, and then chooses the
                                                                                                            	// best endpoint. However, with this setting, if someone uses different ports to
                                                                                                            	// connect to Global Accelerator, their connections might not be always routed to
                                                                                                            	// the same endpoint because the hash value changes. If you want a given client to
                                                                                                            	// always be routed to the same endpoint, set client affinity to SOURCE_IP instead.
                                                                                                            	// When you use the SOURCE_IP setting, Global Accelerator uses the "two-tuple"
                                                                                                            	// (2-tuple) properties— source (client) IP address and destination IP address—to
                                                                                                            	// select the hash value. The default value is NONE.
                                                                                                            	ClientAffinity ClientAffinity
                                                                                                            
                                                                                                            	// The Amazon Resource Name (ARN) of the listener.
                                                                                                            	ListenerArn *string
                                                                                                            
                                                                                                            	// The list of port ranges for the connections from clients to the accelerator.
                                                                                                            	PortRanges []PortRange
                                                                                                            
                                                                                                            	// The protocol for the connections from clients to the accelerator.
                                                                                                            	Protocol Protocol
                                                                                                            }

                                                                                                              A complex type for a listener.

                                                                                                              type ListenerNotFoundException

                                                                                                              type ListenerNotFoundException struct {
                                                                                                              	Message *string
                                                                                                              }

                                                                                                                The listener that you specified doesn't exist.

                                                                                                                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 PortMapping

                                                                                                                type PortMapping struct {
                                                                                                                
                                                                                                                	// The accelerator port.
                                                                                                                	AcceleratorPort *int32
                                                                                                                
                                                                                                                	// The EC2 instance IP address and port number in the virtual private cloud (VPC)
                                                                                                                	// subnet.
                                                                                                                	DestinationSocketAddress *SocketAddress
                                                                                                                
                                                                                                                	// Indicates whether or not a port mapping destination can receive traffic. The
                                                                                                                	// value is either ALLOW, if traffic is allowed to the destination, or DENY, if
                                                                                                                	// traffic is not allowed to the destination.
                                                                                                                	DestinationTrafficState CustomRoutingDestinationTrafficState
                                                                                                                
                                                                                                                	// The Amazon Resource Name (ARN) of the endpoint group.
                                                                                                                	EndpointGroupArn *string
                                                                                                                
                                                                                                                	// The IP address of the VPC subnet (the subnet ID).
                                                                                                                	EndpointId *string
                                                                                                                
                                                                                                                	// The protocols supported by the endpoint group.
                                                                                                                	Protocols []CustomRoutingProtocol
                                                                                                                }

                                                                                                                  Returns the ports and associated IP addresses and ports of Amazon EC2 instances in your virtual private cloud (VPC) subnets. Custom routing is a port mapping protocol in AWS Global Accelerator that statically associates port ranges with VPC subnets, which allows Global Accelerator to route to specific instances and ports within one or more subnets.

                                                                                                                  type PortOverride

                                                                                                                  type PortOverride struct {
                                                                                                                  
                                                                                                                  	// The endpoint port that you want a listener port to be mapped to. This is the
                                                                                                                  	// port on the endpoint, such as the Application Load Balancer or Amazon EC2
                                                                                                                  	// instance.
                                                                                                                  	EndpointPort *int32
                                                                                                                  
                                                                                                                  	// The listener port that you want to map to a specific endpoint port. This is the
                                                                                                                  	// port that user traffic arrives to the Global Accelerator on.
                                                                                                                  	ListenerPort *int32
                                                                                                                  }

                                                                                                                    Override specific listener ports used to route traffic to endpoints that are part of an endpoint group. For example, you can create a port override in which the listener receives user traffic on ports 80 and 443, but your accelerator routes that traffic to ports 1080 and 1443, respectively, on the endpoints. For more information, see Port overrides (https://docs.aws.amazon.com/global-accelerator/latest/dg/about-endpoint-groups-port-override.html) in the AWS Global Accelerator Developer Guide.

                                                                                                                    type PortRange

                                                                                                                    type PortRange struct {
                                                                                                                    
                                                                                                                    	// The first port in the range of ports, inclusive.
                                                                                                                    	FromPort *int32
                                                                                                                    
                                                                                                                    	// The last port in the range of ports, inclusive.
                                                                                                                    	ToPort *int32
                                                                                                                    }

                                                                                                                      A complex type for a range of ports for a listener.

                                                                                                                      type Protocol

                                                                                                                      type Protocol string
                                                                                                                      const (
                                                                                                                      	ProtocolTcp Protocol = "TCP"
                                                                                                                      	ProtocolUdp Protocol = "UDP"
                                                                                                                      )

                                                                                                                        Enum values for Protocol

                                                                                                                        func (Protocol) Values

                                                                                                                        func (Protocol) Values() []Protocol

                                                                                                                          Values returns all known values for Protocol. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                          type SocketAddress

                                                                                                                          type SocketAddress struct {
                                                                                                                          
                                                                                                                          	// The IP address for the socket address.
                                                                                                                          	IpAddress *string
                                                                                                                          
                                                                                                                          	// The port for the socket address.
                                                                                                                          	Port *int32
                                                                                                                          }

                                                                                                                            An IP address/port combination.

                                                                                                                            type Tag

                                                                                                                            type Tag struct {
                                                                                                                            
                                                                                                                            	// A string that contains a Tag key.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Key *string
                                                                                                                            
                                                                                                                            	// A string that contains a Tag value.
                                                                                                                            	//
                                                                                                                            	// This member is required.
                                                                                                                            	Value *string
                                                                                                                            }

                                                                                                                              A complex type that contains a Tag key and Tag value.