ga

package
v1.61.1038 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 20, 2021 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source 
var EndpointType = "regional"

EndpointType regional or central

Functions

func GetEndpointMap 

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType 

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty 

func SetClientProperty(client *Client, propertyName string, propertyValue interface{})

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient 

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types

type AcceleratorsInBandwidthPackageAddAccelerator 

type AcceleratorsInBandwidthPackageAddAccelerator struct {
	Accelerator []string `json:"Accelerator" xml:"Accelerator"`
}

AcceleratorsInBandwidthPackageAddAccelerator is a nested struct in ga response

type AcceleratorsInBandwidthPackageRemoveAccelerator 

type AcceleratorsInBandwidthPackageRemoveAccelerator struct {
	Accelerator []string `json:"Accelerator" xml:"Accelerator"`
}

AcceleratorsInBandwidthPackageRemoveAccelerator is a nested struct in ga response

type AcceleratorsInDescribeBandwidthPackage 

type AcceleratorsInDescribeBandwidthPackage struct {
	Accelerator []string `json:"Accelerator" xml:"Accelerator"`
}

AcceleratorsInDescribeBandwidthPackage is a nested struct in ga response

type AcceleratorsInListAccelerators 

type AcceleratorsInListAccelerators struct {
	AcceleratorsItem []AcceleratorsItem `json:"Accelerators" xml:"Accelerators"`
}

AcceleratorsInListAccelerators is a nested struct in ga response

type AcceleratorsInListBandwidthPackages 

type AcceleratorsInListBandwidthPackages struct {
	Accelerator []string `json:"Accelerator" xml:"Accelerator"`
}

AcceleratorsInListBandwidthPackages is a nested struct in ga response

type AcceleratorsInListBandwidthackages 

type AcceleratorsInListBandwidthackages struct {
	Accelerator []string `json:"Accelerator" xml:"Accelerator"`
}

AcceleratorsInListBandwidthackages is a nested struct in ga response

type AcceleratorsItem 

type AcceleratorsItem struct {
	AcceleratorId               string                      `json:"AcceleratorId" xml:"AcceleratorId"`
	Name                        string                      `json:"Name" xml:"Name"`
	Description                 string                      `json:"Description" xml:"Description"`
	Bandwidth                   int                         `json:"Bandwidth" xml:"Bandwidth"`
	Type                        string                      `json:"Type" xml:"Type"`
	InstanceChargeType          string                      `json:"InstanceChargeType" xml:"InstanceChargeType"`
	ExpiredTime                 int64                       `json:"ExpiredTime" xml:"ExpiredTime"`
	CenId                       string                      `json:"CenId" xml:"CenId"`
	State                       string                      `json:"State" xml:"State"`
	DnsName                     string                      `json:"DnsName" xml:"DnsName"`
	CreateTime                  int64                       `json:"CreateTime" xml:"CreateTime"`
	RegionId                    string                      `json:"RegionId" xml:"RegionId"`
	Spec                        string                      `json:"Spec" xml:"Spec"`
	DdosId                      string                      `json:"DdosId" xml:"DdosId"`
	SecondDnsName               string                      `json:"SecondDnsName" xml:"SecondDnsName"`
	BasicBandwidthPackage       BasicBandwidthPackage       `json:"BasicBandwidthPackage" xml:"BasicBandwidthPackage"`
	CrossDomainBandwidthPackage CrossDomainBandwidthPackage `json:"CrossDomainBandwidthPackage" xml:"CrossDomainBandwidthPackage"`
}

AcceleratorsItem is a nested struct in ga response

type AreasInListAccelerateAreas 

type AreasInListAccelerateAreas struct {
	AreasItem []AreasItem `json:"Areas" xml:"Areas"`
}

AreasInListAccelerateAreas is a nested struct in ga response

type AreasInListAvailableAccelerateAreas 

type AreasInListAvailableAccelerateAreas struct {
	AreasItem []AreasItem `json:"Areas" xml:"Areas"`
}

AreasInListAvailableAccelerateAreas is a nested struct in ga response

type AreasItem 

type AreasItem struct {
	LocalName  string           `json:"LocalName" xml:"LocalName"`
	AreaId     string           `json:"AreaId" xml:"AreaId"`
	RegionList []RegionListItem `json:"RegionList" xml:"RegionList"`
}

AreasItem is a nested struct in ga response

type AttachDdosToAcceleratorRequest 

type AttachDdosToAcceleratorRequest struct {
	*requests.RpcRequest
	DdosId        string `position:"Query" name:"DdosId"`
	DdosRegionId  string `position:"Query" name:"DdosRegionId"`
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

AttachDdosToAcceleratorRequest is the request struct for api AttachDdosToAccelerator

func CreateAttachDdosToAcceleratorRequest 

func CreateAttachDdosToAcceleratorRequest() (request *AttachDdosToAcceleratorRequest)

CreateAttachDdosToAcceleratorRequest creates a request to invoke AttachDdosToAccelerator API

type AttachDdosToAcceleratorResponse 

type AttachDdosToAcceleratorResponse struct {
	*responses.BaseResponse
	GaId      string `json:"GaId" xml:"GaId"`
	DdosId    string `json:"DdosId" xml:"DdosId"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

AttachDdosToAcceleratorResponse is the response struct for api AttachDdosToAccelerator

func CreateAttachDdosToAcceleratorResponse 

func CreateAttachDdosToAcceleratorResponse() (response *AttachDdosToAcceleratorResponse)

CreateAttachDdosToAcceleratorResponse creates a response to parse from AttachDdosToAccelerator response

type BackendPort 

type BackendPort struct {
	ToPort   string `json:"ToPort" xml:"ToPort"`
	FromPort string `json:"FromPort" xml:"FromPort"`
}

BackendPort is a nested struct in ga response

type BackendPortsInDescribeListener 

type BackendPortsInDescribeListener struct {
	BackendPort []BackendPort `json:"BackendPort" xml:"BackendPort"`
}

BackendPortsInDescribeListener is a nested struct in ga response

type BackendPortsInListListeners 

type BackendPortsInListListeners struct {
	BackendPort []BackendPort `json:"BackendPort" xml:"BackendPort"`
}

BackendPortsInListListeners is a nested struct in ga response

type BandwidthPackage 

type BandwidthPackage struct {
	Name                   string   `json:"Name" xml:"Name"`
	ExpiredTime            string   `json:"ExpiredTime" xml:"ExpiredTime"`
	ChargeType             string   `json:"ChargeType" xml:"ChargeType"`
	CreateTime             string   `json:"CreateTime" xml:"CreateTime"`
	Bandwidth              int      `json:"Bandwidth" xml:"Bandwidth"`
	State                  string   `json:"State" xml:"State"`
	RegionId               string   `json:"RegionId" xml:"RegionId"`
	CbnGeographicRegionIdA string   `json:"CbnGeographicRegionIdA" xml:"CbnGeographicRegionIdA"`
	BillingType            string   `json:"BillingType" xml:"BillingType"`
	BandwidthType          string   `json:"BandwidthType" xml:"BandwidthType"`
	BandwidthPackageId     string   `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	Description            string   `json:"Description" xml:"Description"`
	CbnGeographicRegionIdB string   `json:"CbnGeographicRegionIdB" xml:"CbnGeographicRegionIdB"`
	Type                   string   `json:"Type" xml:"Type"`
	Accelerators           []string `json:"Accelerators" xml:"Accelerators"`
}

BandwidthPackage is a nested struct in ga response

type BandwidthPackageAddAcceleratorRequest 

type BandwidthPackageAddAcceleratorRequest struct {
	*requests.RpcRequest
	BandwidthPackageId string `position:"Query" name:"BandwidthPackageId"`
	AcceleratorId      string `position:"Query" name:"AcceleratorId"`
}

BandwidthPackageAddAcceleratorRequest is the request struct for api BandwidthPackageAddAccelerator

func CreateBandwidthPackageAddAcceleratorRequest 

func CreateBandwidthPackageAddAcceleratorRequest() (request *BandwidthPackageAddAcceleratorRequest)

CreateBandwidthPackageAddAcceleratorRequest creates a request to invoke BandwidthPackageAddAccelerator API

type BandwidthPackageAddAcceleratorResponse 

type BandwidthPackageAddAcceleratorResponse struct {
	*responses.BaseResponse
	BandwidthPackageId string   `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	RequestId          string   `json:"RequestId" xml:"RequestId"`
	Accelerators       []string `json:"Accelerators" xml:"Accelerators"`
}

BandwidthPackageAddAcceleratorResponse is the response struct for api BandwidthPackageAddAccelerator

func CreateBandwidthPackageAddAcceleratorResponse 

func CreateBandwidthPackageAddAcceleratorResponse() (response *BandwidthPackageAddAcceleratorResponse)

CreateBandwidthPackageAddAcceleratorResponse creates a response to parse from BandwidthPackageAddAccelerator response

type BandwidthPackageRemoveAcceleratorRequest 

type BandwidthPackageRemoveAcceleratorRequest struct {
	*requests.RpcRequest
	BandwidthPackageId string `position:"Query" name:"BandwidthPackageId"`
	AcceleratorId      string `position:"Query" name:"AcceleratorId"`
}

BandwidthPackageRemoveAcceleratorRequest is the request struct for api BandwidthPackageRemoveAccelerator

func CreateBandwidthPackageRemoveAcceleratorRequest 

func CreateBandwidthPackageRemoveAcceleratorRequest() (request *BandwidthPackageRemoveAcceleratorRequest)

CreateBandwidthPackageRemoveAcceleratorRequest creates a request to invoke BandwidthPackageRemoveAccelerator API

type BandwidthPackageRemoveAcceleratorResponse 

type BandwidthPackageRemoveAcceleratorResponse struct {
	*responses.BaseResponse
	BandwidthPackageId string   `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	RequestId          string   `json:"RequestId" xml:"RequestId"`
	Accelerators       []string `json:"Accelerators" xml:"Accelerators"`
}

BandwidthPackageRemoveAcceleratorResponse is the response struct for api BandwidthPackageRemoveAccelerator

func CreateBandwidthPackageRemoveAcceleratorResponse 

func CreateBandwidthPackageRemoveAcceleratorResponse() (response *BandwidthPackageRemoveAcceleratorResponse)

CreateBandwidthPackageRemoveAcceleratorResponse creates a response to parse from BandwidthPackageRemoveAccelerator response

type BandwidthPackagesInListBandwidthPackages 

type BandwidthPackagesInListBandwidthPackages struct {
	BandwidthPackage []BandwidthPackage `json:"BandwidthPackage" xml:"BandwidthPackage"`
}

BandwidthPackagesInListBandwidthPackages is a nested struct in ga response

type BandwidthPackagesInListBandwidthackages 

type BandwidthPackagesInListBandwidthackages struct {
	BandwidthPackage []BandwidthPackage `json:"BandwidthPackage" xml:"BandwidthPackage"`
}

BandwidthPackagesInListBandwidthackages is a nested struct in ga response

type BasicBandwidthPackage 

type BasicBandwidthPackage struct {
	Bandwidth     int    `json:"Bandwidth" xml:"Bandwidth"`
	BandwidthType string `json:"BandwidthType" xml:"BandwidthType"`
	InstanceId    string `json:"InstanceId" xml:"InstanceId"`
}

BasicBandwidthPackage is a nested struct in ga response

type Certificate 

type Certificate struct {
	Id   string `json:"Id" xml:"Id"`
	Type string `json:"Type" xml:"Type"`
}

Certificate is a nested struct in ga response

type CertificatesInDescribeListener 

type CertificatesInDescribeListener struct {
	Certificate []Certificate `json:"Certificate" xml:"Certificate"`
}

CertificatesInDescribeListener is a nested struct in ga response

type CertificatesInListListeners 

type CertificatesInListListeners struct {
	Certificate []Certificate `json:"Certificate" xml:"Certificate"`
}

CertificatesInListListeners is a nested struct in ga response

type Client 

type Client struct {
	sdk.Client
}

Client is the sdk client struct, each func corresponds to an OpenAPI

func NewClient 

func NewClient() (client *Client, err error)

NewClient creates a sdk client with environment variables

func NewClientWithAccessKey 

func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)

NewClientWithAccessKey is a shortcut to create sdk client with accesskey usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithEcsRamRole 

func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)

NewClientWithEcsRamRole is a shortcut to create sdk client with ecs ram role usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithOptions 

func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)

NewClientWithOptions creates a sdk client with regionId/sdkConfig/credential this is the common api to create a sdk client

func NewClientWithProvider 

func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)

NewClientWithProvider creates a sdk client with providers usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArn 

func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRamRoleArnAndPolicy 

func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error)

NewClientWithRamRoleArn is a shortcut to create sdk client with ram roleArn and policy usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithRsaKeyPair 

func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)

NewClientWithRsaKeyPair is a shortcut to create sdk client with rsa key pair usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func NewClientWithStsToken 

func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)

NewClientWithStsToken is a shortcut to create sdk client with sts token usage: https://github.com/aliyun/alibaba-cloud-sdk-go/blob/master/docs/2-Client-EN.md

func (*Client) AttachDdosToAccelerator 

func (client *Client) AttachDdosToAccelerator(request *AttachDdosToAcceleratorRequest) (response *AttachDdosToAcceleratorResponse, err error)

AttachDdosToAccelerator invokes the ga.AttachDdosToAccelerator API synchronously

func (*Client) AttachDdosToAcceleratorWithCallback 

func (client *Client) AttachDdosToAcceleratorWithCallback(request *AttachDdosToAcceleratorRequest, callback func(response *AttachDdosToAcceleratorResponse, err error)) <-chan int

AttachDdosToAcceleratorWithCallback invokes the ga.AttachDdosToAccelerator API asynchronously

func (*Client) AttachDdosToAcceleratorWithChan 

func (client *Client) AttachDdosToAcceleratorWithChan(request *AttachDdosToAcceleratorRequest) (<-chan *AttachDdosToAcceleratorResponse, <-chan error)

AttachDdosToAcceleratorWithChan invokes the ga.AttachDdosToAccelerator API asynchronously

func (*Client) BandwidthPackageAddAccelerator 

func (client *Client) BandwidthPackageAddAccelerator(request *BandwidthPackageAddAcceleratorRequest) (response *BandwidthPackageAddAcceleratorResponse, err error)

BandwidthPackageAddAccelerator invokes the ga.BandwidthPackageAddAccelerator API synchronously

func (*Client) BandwidthPackageAddAcceleratorWithCallback 

func (client *Client) BandwidthPackageAddAcceleratorWithCallback(request *BandwidthPackageAddAcceleratorRequest, callback func(response *BandwidthPackageAddAcceleratorResponse, err error)) <-chan int

BandwidthPackageAddAcceleratorWithCallback invokes the ga.BandwidthPackageAddAccelerator API asynchronously

func (*Client) BandwidthPackageAddAcceleratorWithChan 

func (client *Client) BandwidthPackageAddAcceleratorWithChan(request *BandwidthPackageAddAcceleratorRequest) (<-chan *BandwidthPackageAddAcceleratorResponse, <-chan error)

BandwidthPackageAddAcceleratorWithChan invokes the ga.BandwidthPackageAddAccelerator API asynchronously

func (*Client) BandwidthPackageRemoveAccelerator 

func (client *Client) BandwidthPackageRemoveAccelerator(request *BandwidthPackageRemoveAcceleratorRequest) (response *BandwidthPackageRemoveAcceleratorResponse, err error)

BandwidthPackageRemoveAccelerator invokes the ga.BandwidthPackageRemoveAccelerator API synchronously

func (*Client) BandwidthPackageRemoveAcceleratorWithCallback 

func (client *Client) BandwidthPackageRemoveAcceleratorWithCallback(request *BandwidthPackageRemoveAcceleratorRequest, callback func(response *BandwidthPackageRemoveAcceleratorResponse, err error)) <-chan int

BandwidthPackageRemoveAcceleratorWithCallback invokes the ga.BandwidthPackageRemoveAccelerator API asynchronously

func (*Client) BandwidthPackageRemoveAcceleratorWithChan 

func (client *Client) BandwidthPackageRemoveAcceleratorWithChan(request *BandwidthPackageRemoveAcceleratorRequest) (<-chan *BandwidthPackageRemoveAcceleratorResponse, <-chan error)

BandwidthPackageRemoveAcceleratorWithChan invokes the ga.BandwidthPackageRemoveAccelerator API asynchronously

func (*Client) ConfigEndpointProbe 

func (client *Client) ConfigEndpointProbe(request *ConfigEndpointProbeRequest) (response *ConfigEndpointProbeResponse, err error)

ConfigEndpointProbe invokes the ga.ConfigEndpointProbe API synchronously

func (*Client) ConfigEndpointProbeWithCallback 

func (client *Client) ConfigEndpointProbeWithCallback(request *ConfigEndpointProbeRequest, callback func(response *ConfigEndpointProbeResponse, err error)) <-chan int

ConfigEndpointProbeWithCallback invokes the ga.ConfigEndpointProbe API asynchronously

func (*Client) ConfigEndpointProbeWithChan 

func (client *Client) ConfigEndpointProbeWithChan(request *ConfigEndpointProbeRequest) (<-chan *ConfigEndpointProbeResponse, <-chan error)

ConfigEndpointProbeWithChan invokes the ga.ConfigEndpointProbe API asynchronously

func (*Client) CreateAccelerator 

func (client *Client) CreateAccelerator(request *CreateAcceleratorRequest) (response *CreateAcceleratorResponse, err error)

CreateAccelerator invokes the ga.CreateAccelerator API synchronously

func (*Client) CreateAcceleratorWithCallback 

func (client *Client) CreateAcceleratorWithCallback(request *CreateAcceleratorRequest, callback func(response *CreateAcceleratorResponse, err error)) <-chan int

CreateAcceleratorWithCallback invokes the ga.CreateAccelerator API asynchronously

func (*Client) CreateAcceleratorWithChan 

func (client *Client) CreateAcceleratorWithChan(request *CreateAcceleratorRequest) (<-chan *CreateAcceleratorResponse, <-chan error)

CreateAcceleratorWithChan invokes the ga.CreateAccelerator API asynchronously

func (*Client) CreateBandwidthPackage 

func (client *Client) CreateBandwidthPackage(request *CreateBandwidthPackageRequest) (response *CreateBandwidthPackageResponse, err error)

CreateBandwidthPackage invokes the ga.CreateBandwidthPackage API synchronously

func (*Client) CreateBandwidthPackageWithCallback 

func (client *Client) CreateBandwidthPackageWithCallback(request *CreateBandwidthPackageRequest, callback func(response *CreateBandwidthPackageResponse, err error)) <-chan int

CreateBandwidthPackageWithCallback invokes the ga.CreateBandwidthPackage API asynchronously

func (*Client) CreateBandwidthPackageWithChan 

func (client *Client) CreateBandwidthPackageWithChan(request *CreateBandwidthPackageRequest) (<-chan *CreateBandwidthPackageResponse, <-chan error)

CreateBandwidthPackageWithChan invokes the ga.CreateBandwidthPackage API asynchronously

func (*Client) CreateEndpointGroup 

func (client *Client) CreateEndpointGroup(request *CreateEndpointGroupRequest) (response *CreateEndpointGroupResponse, err error)

CreateEndpointGroup invokes the ga.CreateEndpointGroup API synchronously

func (*Client) CreateEndpointGroupWithCallback 

func (client *Client) CreateEndpointGroupWithCallback(request *CreateEndpointGroupRequest, callback func(response *CreateEndpointGroupResponse, err error)) <-chan int

CreateEndpointGroupWithCallback invokes the ga.CreateEndpointGroup API asynchronously

func (*Client) CreateEndpointGroupWithChan 

func (client *Client) CreateEndpointGroupWithChan(request *CreateEndpointGroupRequest) (<-chan *CreateEndpointGroupResponse, <-chan error)

CreateEndpointGroupWithChan invokes the ga.CreateEndpointGroup API asynchronously

func (*Client) CreateIpSets 

func (client *Client) CreateIpSets(request *CreateIpSetsRequest) (response *CreateIpSetsResponse, err error)

CreateIpSets invokes the ga.CreateIpSets API synchronously

func (*Client) CreateIpSetsWithCallback 

func (client *Client) CreateIpSetsWithCallback(request *CreateIpSetsRequest, callback func(response *CreateIpSetsResponse, err error)) <-chan int

CreateIpSetsWithCallback invokes the ga.CreateIpSets API asynchronously

func (*Client) CreateIpSetsWithChan 

func (client *Client) CreateIpSetsWithChan(request *CreateIpSetsRequest) (<-chan *CreateIpSetsResponse, <-chan error)

CreateIpSetsWithChan invokes the ga.CreateIpSets API asynchronously

func (*Client) CreateListener 

func (client *Client) CreateListener(request *CreateListenerRequest) (response *CreateListenerResponse, err error)

CreateListener invokes the ga.CreateListener API synchronously

func (*Client) CreateListenerWithCallback 

func (client *Client) CreateListenerWithCallback(request *CreateListenerRequest, callback func(response *CreateListenerResponse, err error)) <-chan int

CreateListenerWithCallback invokes the ga.CreateListener API asynchronously

func (*Client) CreateListenerWithChan 

func (client *Client) CreateListenerWithChan(request *CreateListenerRequest) (<-chan *CreateListenerResponse, <-chan error)

CreateListenerWithChan invokes the ga.CreateListener API asynchronously

func (*Client) DeleteAccelerator 

func (client *Client) DeleteAccelerator(request *DeleteAcceleratorRequest) (response *DeleteAcceleratorResponse, err error)

DeleteAccelerator invokes the ga.DeleteAccelerator API synchronously

func (*Client) DeleteAcceleratorWithCallback 

func (client *Client) DeleteAcceleratorWithCallback(request *DeleteAcceleratorRequest, callback func(response *DeleteAcceleratorResponse, err error)) <-chan int

DeleteAcceleratorWithCallback invokes the ga.DeleteAccelerator API asynchronously

func (*Client) DeleteAcceleratorWithChan 

func (client *Client) DeleteAcceleratorWithChan(request *DeleteAcceleratorRequest) (<-chan *DeleteAcceleratorResponse, <-chan error)

DeleteAcceleratorWithChan invokes the ga.DeleteAccelerator API asynchronously

func (*Client) DeleteBandwidthPackage 

func (client *Client) DeleteBandwidthPackage(request *DeleteBandwidthPackageRequest) (response *DeleteBandwidthPackageResponse, err error)

DeleteBandwidthPackage invokes the ga.DeleteBandwidthPackage API synchronously

func (*Client) DeleteBandwidthPackageWithCallback 

func (client *Client) DeleteBandwidthPackageWithCallback(request *DeleteBandwidthPackageRequest, callback func(response *DeleteBandwidthPackageResponse, err error)) <-chan int

DeleteBandwidthPackageWithCallback invokes the ga.DeleteBandwidthPackage API asynchronously

func (*Client) DeleteBandwidthPackageWithChan 

func (client *Client) DeleteBandwidthPackageWithChan(request *DeleteBandwidthPackageRequest) (<-chan *DeleteBandwidthPackageResponse, <-chan error)

DeleteBandwidthPackageWithChan invokes the ga.DeleteBandwidthPackage API asynchronously

func (*Client) DeleteEndpointGroup 

func (client *Client) DeleteEndpointGroup(request *DeleteEndpointGroupRequest) (response *DeleteEndpointGroupResponse, err error)

DeleteEndpointGroup invokes the ga.DeleteEndpointGroup API synchronously

func (*Client) DeleteEndpointGroupWithCallback 

func (client *Client) DeleteEndpointGroupWithCallback(request *DeleteEndpointGroupRequest, callback func(response *DeleteEndpointGroupResponse, err error)) <-chan int

DeleteEndpointGroupWithCallback invokes the ga.DeleteEndpointGroup API asynchronously

func (*Client) DeleteEndpointGroupWithChan 

func (client *Client) DeleteEndpointGroupWithChan(request *DeleteEndpointGroupRequest) (<-chan *DeleteEndpointGroupResponse, <-chan error)

DeleteEndpointGroupWithChan invokes the ga.DeleteEndpointGroup API asynchronously

func (*Client) DeleteIpSet 

func (client *Client) DeleteIpSet(request *DeleteIpSetRequest) (response *DeleteIpSetResponse, err error)

DeleteIpSet invokes the ga.DeleteIpSet API synchronously

func (*Client) DeleteIpSetWithCallback 

func (client *Client) DeleteIpSetWithCallback(request *DeleteIpSetRequest, callback func(response *DeleteIpSetResponse, err error)) <-chan int

DeleteIpSetWithCallback invokes the ga.DeleteIpSet API asynchronously

func (*Client) DeleteIpSetWithChan 

func (client *Client) DeleteIpSetWithChan(request *DeleteIpSetRequest) (<-chan *DeleteIpSetResponse, <-chan error)

DeleteIpSetWithChan invokes the ga.DeleteIpSet API asynchronously

func (*Client) DeleteIpSets 

func (client *Client) DeleteIpSets(request *DeleteIpSetsRequest) (response *DeleteIpSetsResponse, err error)

DeleteIpSets invokes the ga.DeleteIpSets API synchronously

func (*Client) DeleteIpSetsWithCallback 

func (client *Client) DeleteIpSetsWithCallback(request *DeleteIpSetsRequest, callback func(response *DeleteIpSetsResponse, err error)) <-chan int

DeleteIpSetsWithCallback invokes the ga.DeleteIpSets API asynchronously

func (*Client) DeleteIpSetsWithChan 

func (client *Client) DeleteIpSetsWithChan(request *DeleteIpSetsRequest) (<-chan *DeleteIpSetsResponse, <-chan error)

DeleteIpSetsWithChan invokes the ga.DeleteIpSets API asynchronously

func (*Client) DeleteListener 

func (client *Client) DeleteListener(request *DeleteListenerRequest) (response *DeleteListenerResponse, err error)

DeleteListener invokes the ga.DeleteListener API synchronously

func (*Client) DeleteListenerWithCallback 

func (client *Client) DeleteListenerWithCallback(request *DeleteListenerRequest, callback func(response *DeleteListenerResponse, err error)) <-chan int

DeleteListenerWithCallback invokes the ga.DeleteListener API asynchronously

func (*Client) DeleteListenerWithChan 

func (client *Client) DeleteListenerWithChan(request *DeleteListenerRequest) (<-chan *DeleteListenerResponse, <-chan error)

DeleteListenerWithChan invokes the ga.DeleteListener API asynchronously

func (*Client) DescribeAccelerator 

func (client *Client) DescribeAccelerator(request *DescribeAcceleratorRequest) (response *DescribeAcceleratorResponse, err error)

DescribeAccelerator invokes the ga.DescribeAccelerator API synchronously

func (*Client) DescribeAcceleratorWithCallback 

func (client *Client) DescribeAcceleratorWithCallback(request *DescribeAcceleratorRequest, callback func(response *DescribeAcceleratorResponse, err error)) <-chan int

DescribeAcceleratorWithCallback invokes the ga.DescribeAccelerator API asynchronously

func (*Client) DescribeAcceleratorWithChan 

func (client *Client) DescribeAcceleratorWithChan(request *DescribeAcceleratorRequest) (<-chan *DescribeAcceleratorResponse, <-chan error)

DescribeAcceleratorWithChan invokes the ga.DescribeAccelerator API asynchronously

func (*Client) DescribeBandwidthPackage 

func (client *Client) DescribeBandwidthPackage(request *DescribeBandwidthPackageRequest) (response *DescribeBandwidthPackageResponse, err error)

DescribeBandwidthPackage invokes the ga.DescribeBandwidthPackage API synchronously

func (*Client) DescribeBandwidthPackageWithCallback 

func (client *Client) DescribeBandwidthPackageWithCallback(request *DescribeBandwidthPackageRequest, callback func(response *DescribeBandwidthPackageResponse, err error)) <-chan int

DescribeBandwidthPackageWithCallback invokes the ga.DescribeBandwidthPackage API asynchronously

func (*Client) DescribeBandwidthPackageWithChan 

func (client *Client) DescribeBandwidthPackageWithChan(request *DescribeBandwidthPackageRequest) (<-chan *DescribeBandwidthPackageResponse, <-chan error)

DescribeBandwidthPackageWithChan invokes the ga.DescribeBandwidthPackage API asynchronously

func (*Client) DescribeEndpointGroup 

func (client *Client) DescribeEndpointGroup(request *DescribeEndpointGroupRequest) (response *DescribeEndpointGroupResponse, err error)

DescribeEndpointGroup invokes the ga.DescribeEndpointGroup API synchronously

func (*Client) DescribeEndpointGroupWithCallback 

func (client *Client) DescribeEndpointGroupWithCallback(request *DescribeEndpointGroupRequest, callback func(response *DescribeEndpointGroupResponse, err error)) <-chan int

DescribeEndpointGroupWithCallback invokes the ga.DescribeEndpointGroup API asynchronously

func (*Client) DescribeEndpointGroupWithChan 

func (client *Client) DescribeEndpointGroupWithChan(request *DescribeEndpointGroupRequest) (<-chan *DescribeEndpointGroupResponse, <-chan error)

DescribeEndpointGroupWithChan invokes the ga.DescribeEndpointGroup API asynchronously

func (*Client) DescribeIpSet 

func (client *Client) DescribeIpSet(request *DescribeIpSetRequest) (response *DescribeIpSetResponse, err error)

DescribeIpSet invokes the ga.DescribeIpSet API synchronously

func (*Client) DescribeIpSetWithCallback 

func (client *Client) DescribeIpSetWithCallback(request *DescribeIpSetRequest, callback func(response *DescribeIpSetResponse, err error)) <-chan int

DescribeIpSetWithCallback invokes the ga.DescribeIpSet API asynchronously

func (*Client) DescribeIpSetWithChan 

func (client *Client) DescribeIpSetWithChan(request *DescribeIpSetRequest) (<-chan *DescribeIpSetResponse, <-chan error)

DescribeIpSetWithChan invokes the ga.DescribeIpSet API asynchronously

func (*Client) DescribeListener 

func (client *Client) DescribeListener(request *DescribeListenerRequest) (response *DescribeListenerResponse, err error)

DescribeListener invokes the ga.DescribeListener API synchronously

func (*Client) DescribeListenerWithCallback 

func (client *Client) DescribeListenerWithCallback(request *DescribeListenerRequest, callback func(response *DescribeListenerResponse, err error)) <-chan int

DescribeListenerWithCallback invokes the ga.DescribeListener API asynchronously

func (*Client) DescribeListenerWithChan 

func (client *Client) DescribeListenerWithChan(request *DescribeListenerRequest) (<-chan *DescribeListenerResponse, <-chan error)

DescribeListenerWithChan invokes the ga.DescribeListener API asynchronously

func (*Client) DescribeRegions 

func (client *Client) DescribeRegions(request *DescribeRegionsRequest) (response *DescribeRegionsResponse, err error)

DescribeRegions invokes the ga.DescribeRegions API synchronously

func (*Client) DescribeRegionsWithCallback 

func (client *Client) DescribeRegionsWithCallback(request *DescribeRegionsRequest, callback func(response *DescribeRegionsResponse, err error)) <-chan int

DescribeRegionsWithCallback invokes the ga.DescribeRegions API asynchronously

func (*Client) DescribeRegionsWithChan 

func (client *Client) DescribeRegionsWithChan(request *DescribeRegionsRequest) (<-chan *DescribeRegionsResponse, <-chan error)

DescribeRegionsWithChan invokes the ga.DescribeRegions API asynchronously

func (*Client) DetachDdosFromAccelerator 

func (client *Client) DetachDdosFromAccelerator(request *DetachDdosFromAcceleratorRequest) (response *DetachDdosFromAcceleratorResponse, err error)

DetachDdosFromAccelerator invokes the ga.DetachDdosFromAccelerator API synchronously

func (*Client) DetachDdosFromAcceleratorWithCallback 

func (client *Client) DetachDdosFromAcceleratorWithCallback(request *DetachDdosFromAcceleratorRequest, callback func(response *DetachDdosFromAcceleratorResponse, err error)) <-chan int

DetachDdosFromAcceleratorWithCallback invokes the ga.DetachDdosFromAccelerator API asynchronously

func (*Client) DetachDdosFromAcceleratorWithChan 

func (client *Client) DetachDdosFromAcceleratorWithChan(request *DetachDdosFromAcceleratorRequest) (<-chan *DetachDdosFromAcceleratorResponse, <-chan error)

DetachDdosFromAcceleratorWithChan invokes the ga.DetachDdosFromAccelerator API asynchronously

func (*Client) ListAccelerateAreas 

func (client *Client) ListAccelerateAreas(request *ListAccelerateAreasRequest) (response *ListAccelerateAreasResponse, err error)

ListAccelerateAreas invokes the ga.ListAccelerateAreas API synchronously

func (*Client) ListAccelerateAreasWithCallback 

func (client *Client) ListAccelerateAreasWithCallback(request *ListAccelerateAreasRequest, callback func(response *ListAccelerateAreasResponse, err error)) <-chan int

ListAccelerateAreasWithCallback invokes the ga.ListAccelerateAreas API asynchronously

func (*Client) ListAccelerateAreasWithChan 

func (client *Client) ListAccelerateAreasWithChan(request *ListAccelerateAreasRequest) (<-chan *ListAccelerateAreasResponse, <-chan error)

ListAccelerateAreasWithChan invokes the ga.ListAccelerateAreas API asynchronously

func (*Client) ListAccelerators 

func (client *Client) ListAccelerators(request *ListAcceleratorsRequest) (response *ListAcceleratorsResponse, err error)

ListAccelerators invokes the ga.ListAccelerators API synchronously

func (*Client) ListAcceleratorsWithCallback 

func (client *Client) ListAcceleratorsWithCallback(request *ListAcceleratorsRequest, callback func(response *ListAcceleratorsResponse, err error)) <-chan int

ListAcceleratorsWithCallback invokes the ga.ListAccelerators API asynchronously

func (*Client) ListAcceleratorsWithChan 

func (client *Client) ListAcceleratorsWithChan(request *ListAcceleratorsRequest) (<-chan *ListAcceleratorsResponse, <-chan error)

ListAcceleratorsWithChan invokes the ga.ListAccelerators API asynchronously

func (*Client) ListAvailableAccelerateAreas 

func (client *Client) ListAvailableAccelerateAreas(request *ListAvailableAccelerateAreasRequest) (response *ListAvailableAccelerateAreasResponse, err error)

ListAvailableAccelerateAreas invokes the ga.ListAvailableAccelerateAreas API synchronously

func (*Client) ListAvailableAccelerateAreasWithCallback 

func (client *Client) ListAvailableAccelerateAreasWithCallback(request *ListAvailableAccelerateAreasRequest, callback func(response *ListAvailableAccelerateAreasResponse, err error)) <-chan int

ListAvailableAccelerateAreasWithCallback invokes the ga.ListAvailableAccelerateAreas API asynchronously

func (*Client) ListAvailableAccelerateAreasWithChan 

func (client *Client) ListAvailableAccelerateAreasWithChan(request *ListAvailableAccelerateAreasRequest) (<-chan *ListAvailableAccelerateAreasResponse, <-chan error)

ListAvailableAccelerateAreasWithChan invokes the ga.ListAvailableAccelerateAreas API asynchronously

func (*Client) ListAvailableBusiRegions 

func (client *Client) ListAvailableBusiRegions(request *ListAvailableBusiRegionsRequest) (response *ListAvailableBusiRegionsResponse, err error)

ListAvailableBusiRegions invokes the ga.ListAvailableBusiRegions API synchronously

func (*Client) ListAvailableBusiRegionsWithCallback 

func (client *Client) ListAvailableBusiRegionsWithCallback(request *ListAvailableBusiRegionsRequest, callback func(response *ListAvailableBusiRegionsResponse, err error)) <-chan int

ListAvailableBusiRegionsWithCallback invokes the ga.ListAvailableBusiRegions API asynchronously

func (*Client) ListAvailableBusiRegionsWithChan 

func (client *Client) ListAvailableBusiRegionsWithChan(request *ListAvailableBusiRegionsRequest) (<-chan *ListAvailableBusiRegionsResponse, <-chan error)

ListAvailableBusiRegionsWithChan invokes the ga.ListAvailableBusiRegions API asynchronously

func (*Client) ListBandwidthPackages 

func (client *Client) ListBandwidthPackages(request *ListBandwidthPackagesRequest) (response *ListBandwidthPackagesResponse, err error)

ListBandwidthPackages invokes the ga.ListBandwidthPackages API synchronously

func (*Client) ListBandwidthPackagesWithCallback 

func (client *Client) ListBandwidthPackagesWithCallback(request *ListBandwidthPackagesRequest, callback func(response *ListBandwidthPackagesResponse, err error)) <-chan int

ListBandwidthPackagesWithCallback invokes the ga.ListBandwidthPackages API asynchronously

func (*Client) ListBandwidthPackagesWithChan 

func (client *Client) ListBandwidthPackagesWithChan(request *ListBandwidthPackagesRequest) (<-chan *ListBandwidthPackagesResponse, <-chan error)

ListBandwidthPackagesWithChan invokes the ga.ListBandwidthPackages API asynchronously

func (*Client) ListBandwidthackages 

func (client *Client) ListBandwidthackages(request *ListBandwidthackagesRequest) (response *ListBandwidthackagesResponse, err error)

ListBandwidthackages invokes the ga.ListBandwidthackages API synchronously

func (*Client) ListBandwidthackagesWithCallback 

func (client *Client) ListBandwidthackagesWithCallback(request *ListBandwidthackagesRequest, callback func(response *ListBandwidthackagesResponse, err error)) <-chan int

ListBandwidthackagesWithCallback invokes the ga.ListBandwidthackages API asynchronously

func (*Client) ListBandwidthackagesWithChan 

func (client *Client) ListBandwidthackagesWithChan(request *ListBandwidthackagesRequest) (<-chan *ListBandwidthackagesResponse, <-chan error)

ListBandwidthackagesWithChan invokes the ga.ListBandwidthackages API asynchronously

func (*Client) ListBusiRegions 

func (client *Client) ListBusiRegions(request *ListBusiRegionsRequest) (response *ListBusiRegionsResponse, err error)

ListBusiRegions invokes the ga.ListBusiRegions API synchronously

func (*Client) ListBusiRegionsWithCallback 

func (client *Client) ListBusiRegionsWithCallback(request *ListBusiRegionsRequest, callback func(response *ListBusiRegionsResponse, err error)) <-chan int

ListBusiRegionsWithCallback invokes the ga.ListBusiRegions API asynchronously

func (*Client) ListBusiRegionsWithChan 

func (client *Client) ListBusiRegionsWithChan(request *ListBusiRegionsRequest) (<-chan *ListBusiRegionsResponse, <-chan error)

ListBusiRegionsWithChan invokes the ga.ListBusiRegions API asynchronously

func (*Client) ListEndpointGroups 

func (client *Client) ListEndpointGroups(request *ListEndpointGroupsRequest) (response *ListEndpointGroupsResponse, err error)

ListEndpointGroups invokes the ga.ListEndpointGroups API synchronously

func (*Client) ListEndpointGroupsWithCallback 

func (client *Client) ListEndpointGroupsWithCallback(request *ListEndpointGroupsRequest, callback func(response *ListEndpointGroupsResponse, err error)) <-chan int

ListEndpointGroupsWithCallback invokes the ga.ListEndpointGroups API asynchronously

func (*Client) ListEndpointGroupsWithChan 

func (client *Client) ListEndpointGroupsWithChan(request *ListEndpointGroupsRequest) (<-chan *ListEndpointGroupsResponse, <-chan error)

ListEndpointGroupsWithChan invokes the ga.ListEndpointGroups API asynchronously

func (*Client) ListIpSets 

func (client *Client) ListIpSets(request *ListIpSetsRequest) (response *ListIpSetsResponse, err error)

ListIpSets invokes the ga.ListIpSets API synchronously

func (*Client) ListIpSetsWithCallback 

func (client *Client) ListIpSetsWithCallback(request *ListIpSetsRequest, callback func(response *ListIpSetsResponse, err error)) <-chan int

ListIpSetsWithCallback invokes the ga.ListIpSets API asynchronously

func (*Client) ListIpSetsWithChan 

func (client *Client) ListIpSetsWithChan(request *ListIpSetsRequest) (<-chan *ListIpSetsResponse, <-chan error)

ListIpSetsWithChan invokes the ga.ListIpSets API asynchronously

func (*Client) ListListeners 

func (client *Client) ListListeners(request *ListListenersRequest) (response *ListListenersResponse, err error)

ListListeners invokes the ga.ListListeners API synchronously

func (*Client) ListListenersWithCallback 

func (client *Client) ListListenersWithCallback(request *ListListenersRequest, callback func(response *ListListenersResponse, err error)) <-chan int

ListListenersWithCallback invokes the ga.ListListeners API asynchronously

func (*Client) ListListenersWithChan 

func (client *Client) ListListenersWithChan(request *ListListenersRequest) (<-chan *ListListenersResponse, <-chan error)

ListListenersWithChan invokes the ga.ListListeners API asynchronously

func (*Client) ReplaceBandwidthPackage 

func (client *Client) ReplaceBandwidthPackage(request *ReplaceBandwidthPackageRequest) (response *ReplaceBandwidthPackageResponse, err error)

ReplaceBandwidthPackage invokes the ga.ReplaceBandwidthPackage API synchronously

func (*Client) ReplaceBandwidthPackageWithCallback 

func (client *Client) ReplaceBandwidthPackageWithCallback(request *ReplaceBandwidthPackageRequest, callback func(response *ReplaceBandwidthPackageResponse, err error)) <-chan int

ReplaceBandwidthPackageWithCallback invokes the ga.ReplaceBandwidthPackage API asynchronously

func (*Client) ReplaceBandwidthPackageWithChan 

func (client *Client) ReplaceBandwidthPackageWithChan(request *ReplaceBandwidthPackageRequest) (<-chan *ReplaceBandwidthPackageResponse, <-chan error)

ReplaceBandwidthPackageWithChan invokes the ga.ReplaceBandwidthPackage API asynchronously

func (*Client) UpdateAccelerator 

func (client *Client) UpdateAccelerator(request *UpdateAcceleratorRequest) (response *UpdateAcceleratorResponse, err error)

UpdateAccelerator invokes the ga.UpdateAccelerator API synchronously

func (*Client) UpdateAcceleratorWithCallback 

func (client *Client) UpdateAcceleratorWithCallback(request *UpdateAcceleratorRequest, callback func(response *UpdateAcceleratorResponse, err error)) <-chan int

UpdateAcceleratorWithCallback invokes the ga.UpdateAccelerator API asynchronously

func (*Client) UpdateAcceleratorWithChan 

func (client *Client) UpdateAcceleratorWithChan(request *UpdateAcceleratorRequest) (<-chan *UpdateAcceleratorResponse, <-chan error)

UpdateAcceleratorWithChan invokes the ga.UpdateAccelerator API asynchronously

func (*Client) UpdateBandwidthPackage 

func (client *Client) UpdateBandwidthPackage(request *UpdateBandwidthPackageRequest) (response *UpdateBandwidthPackageResponse, err error)

UpdateBandwidthPackage invokes the ga.UpdateBandwidthPackage API synchronously

func (*Client) UpdateBandwidthPackageWithCallback 

func (client *Client) UpdateBandwidthPackageWithCallback(request *UpdateBandwidthPackageRequest, callback func(response *UpdateBandwidthPackageResponse, err error)) <-chan int

UpdateBandwidthPackageWithCallback invokes the ga.UpdateBandwidthPackage API asynchronously

func (*Client) UpdateBandwidthPackageWithChan 

func (client *Client) UpdateBandwidthPackageWithChan(request *UpdateBandwidthPackageRequest) (<-chan *UpdateBandwidthPackageResponse, <-chan error)

UpdateBandwidthPackageWithChan invokes the ga.UpdateBandwidthPackage API asynchronously

func (*Client) UpdateEndpointGroup 

func (client *Client) UpdateEndpointGroup(request *UpdateEndpointGroupRequest) (response *UpdateEndpointGroupResponse, err error)

UpdateEndpointGroup invokes the ga.UpdateEndpointGroup API synchronously

func (*Client) UpdateEndpointGroupAttribute 

func (client *Client) UpdateEndpointGroupAttribute(request *UpdateEndpointGroupAttributeRequest) (response *UpdateEndpointGroupAttributeResponse, err error)

UpdateEndpointGroupAttribute invokes the ga.UpdateEndpointGroupAttribute API synchronously

func (*Client) UpdateEndpointGroupAttributeWithCallback 

func (client *Client) UpdateEndpointGroupAttributeWithCallback(request *UpdateEndpointGroupAttributeRequest, callback func(response *UpdateEndpointGroupAttributeResponse, err error)) <-chan int

UpdateEndpointGroupAttributeWithCallback invokes the ga.UpdateEndpointGroupAttribute API asynchronously

func (*Client) UpdateEndpointGroupAttributeWithChan 

func (client *Client) UpdateEndpointGroupAttributeWithChan(request *UpdateEndpointGroupAttributeRequest) (<-chan *UpdateEndpointGroupAttributeResponse, <-chan error)

UpdateEndpointGroupAttributeWithChan invokes the ga.UpdateEndpointGroupAttribute API asynchronously

func (*Client) UpdateEndpointGroupWithCallback 

func (client *Client) UpdateEndpointGroupWithCallback(request *UpdateEndpointGroupRequest, callback func(response *UpdateEndpointGroupResponse, err error)) <-chan int

UpdateEndpointGroupWithCallback invokes the ga.UpdateEndpointGroup API asynchronously

func (*Client) UpdateEndpointGroupWithChan 

func (client *Client) UpdateEndpointGroupWithChan(request *UpdateEndpointGroupRequest) (<-chan *UpdateEndpointGroupResponse, <-chan error)

UpdateEndpointGroupWithChan invokes the ga.UpdateEndpointGroup API asynchronously

func (*Client) UpdateIpSet 

func (client *Client) UpdateIpSet(request *UpdateIpSetRequest) (response *UpdateIpSetResponse, err error)

UpdateIpSet invokes the ga.UpdateIpSet API synchronously

func (*Client) UpdateIpSetWithCallback 

func (client *Client) UpdateIpSetWithCallback(request *UpdateIpSetRequest, callback func(response *UpdateIpSetResponse, err error)) <-chan int

UpdateIpSetWithCallback invokes the ga.UpdateIpSet API asynchronously

func (*Client) UpdateIpSetWithChan 

func (client *Client) UpdateIpSetWithChan(request *UpdateIpSetRequest) (<-chan *UpdateIpSetResponse, <-chan error)

UpdateIpSetWithChan invokes the ga.UpdateIpSet API asynchronously

func (*Client) UpdateIpSets 

func (client *Client) UpdateIpSets(request *UpdateIpSetsRequest) (response *UpdateIpSetsResponse, err error)

UpdateIpSets invokes the ga.UpdateIpSets API synchronously

func (*Client) UpdateIpSetsWithCallback 

func (client *Client) UpdateIpSetsWithCallback(request *UpdateIpSetsRequest, callback func(response *UpdateIpSetsResponse, err error)) <-chan int

UpdateIpSetsWithCallback invokes the ga.UpdateIpSets API asynchronously

func (*Client) UpdateIpSetsWithChan 

func (client *Client) UpdateIpSetsWithChan(request *UpdateIpSetsRequest) (<-chan *UpdateIpSetsResponse, <-chan error)

UpdateIpSetsWithChan invokes the ga.UpdateIpSets API asynchronously

func (*Client) UpdateListener 

func (client *Client) UpdateListener(request *UpdateListenerRequest) (response *UpdateListenerResponse, err error)

UpdateListener invokes the ga.UpdateListener API synchronously

func (*Client) UpdateListenerWithCallback 

func (client *Client) UpdateListenerWithCallback(request *UpdateListenerRequest, callback func(response *UpdateListenerResponse, err error)) <-chan int

UpdateListenerWithCallback invokes the ga.UpdateListener API asynchronously

func (*Client) UpdateListenerWithChan 

func (client *Client) UpdateListenerWithChan(request *UpdateListenerRequest) (<-chan *UpdateListenerResponse, <-chan error)

UpdateListenerWithChan invokes the ga.UpdateListener API asynchronously

type ConfigEndpointProbeRequest 

type ConfigEndpointProbeRequest struct {
	*requests.RpcRequest
	ClientToken     string `position:"Query" name:"ClientToken"`
	Endpoint        string `position:"Query" name:"Endpoint"`
	EndpointType    string `position:"Query" name:"EndpointType"`
	Enable          string `position:"Query" name:"Enable"`
	ProbeProtocol   string `position:"Query" name:"ProbeProtocol"`
	ProbePort       string `position:"Query" name:"ProbePort"`
	EndpointGroupId string `position:"Query" name:"EndpointGroupId"`
}

ConfigEndpointProbeRequest is the request struct for api ConfigEndpointProbe

func CreateConfigEndpointProbeRequest 

func CreateConfigEndpointProbeRequest() (request *ConfigEndpointProbeRequest)

CreateConfigEndpointProbeRequest creates a request to invoke ConfigEndpointProbe API

type ConfigEndpointProbeResponse 

type ConfigEndpointProbeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

ConfigEndpointProbeResponse is the response struct for api ConfigEndpointProbe

func CreateConfigEndpointProbeResponse 

func CreateConfigEndpointProbeResponse() (response *ConfigEndpointProbeResponse)

CreateConfigEndpointProbeResponse creates a response to parse from ConfigEndpointProbe response

type CreateAcceleratorRequest 

type CreateAcceleratorRequest struct {
	*requests.RpcRequest
	AutoPay           requests.Boolean `position:"Query" name:"AutoPay"`
	PromotionOptionNo string           `position:"Query" name:"PromotionOptionNo"`
	ClientToken       string           `position:"Query" name:"ClientToken"`
	AutoUseCoupon     string           `position:"Query" name:"AutoUseCoupon"`
	Spec              string           `position:"Query" name:"Spec"`
	Duration          requests.Integer `position:"Query" name:"Duration"`
	Name              string           `position:"Query" name:"Name"`
	PricingCycle      string           `position:"Query" name:"PricingCycle"`
}

CreateAcceleratorRequest is the request struct for api CreateAccelerator

func CreateCreateAcceleratorRequest 

func CreateCreateAcceleratorRequest() (request *CreateAcceleratorRequest)

CreateCreateAcceleratorRequest creates a request to invoke CreateAccelerator API

type CreateAcceleratorResponse 

type CreateAcceleratorResponse struct {
	*responses.BaseResponse
	AcceleratorId string `json:"AcceleratorId" xml:"AcceleratorId"`
	OrderId       string `json:"OrderId" xml:"OrderId"`
	RequestId     string `json:"RequestId" xml:"RequestId"`
}

CreateAcceleratorResponse is the response struct for api CreateAccelerator

func CreateCreateAcceleratorResponse 

func CreateCreateAcceleratorResponse() (response *CreateAcceleratorResponse)

CreateCreateAcceleratorResponse creates a response to parse from CreateAccelerator response

type CreateBandwidthPackageRequest 

type CreateBandwidthPackageRequest struct {
	*requests.RpcRequest
	BandwidthType          string           `position:"Query" name:"BandwidthType"`
	ClientToken            string           `position:"Query" name:"ClientToken"`
	AutoUseCoupon          string           `position:"Query" name:"AutoUseCoupon"`
	Type                   string           `position:"Query" name:"Type"`
	Duration               string           `position:"Query" name:"Duration"`
	AutoPay                requests.Boolean `position:"Query" name:"AutoPay"`
	PromotionOptionNo      string           `position:"Query" name:"PromotionOptionNo"`
	Bandwidth              requests.Integer `position:"Query" name:"Bandwidth"`
	CbnGeographicRegionIdB string           `position:"Query" name:"CbnGeographicRegionIdB"`
	CbnGeographicRegionIdA string           `position:"Query" name:"CbnGeographicRegionIdA"`
	BillingType            string           `position:"Query" name:"BillingType"`
	ChargeType             string           `position:"Query" name:"ChargeType"`
	PricingCycle           string           `position:"Query" name:"PricingCycle"`
	Ratio                  requests.Integer `position:"Query" name:"Ratio"`
}

CreateBandwidthPackageRequest is the request struct for api CreateBandwidthPackage

func CreateCreateBandwidthPackageRequest 

func CreateCreateBandwidthPackageRequest() (request *CreateBandwidthPackageRequest)

CreateCreateBandwidthPackageRequest creates a request to invoke CreateBandwidthPackage API

type CreateBandwidthPackageResponse 

type CreateBandwidthPackageResponse struct {
	*responses.BaseResponse
	RequestId          string `json:"RequestId" xml:"RequestId"`
	BandwidthPackageId string `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	OrderId            string `json:"OrderId" xml:"OrderId"`
}

CreateBandwidthPackageResponse is the response struct for api CreateBandwidthPackage

func CreateCreateBandwidthPackageResponse 

func CreateCreateBandwidthPackageResponse() (response *CreateBandwidthPackageResponse)

CreateCreateBandwidthPackageResponse creates a response to parse from CreateBandwidthPackage response

type CreateEndpointGroupEndpointConfigurations 

type CreateEndpointGroupEndpointConfigurations struct {
	Endpoint                   string `name:"Endpoint"`
	Type                       string `name:"Type"`
	Weight                     string `name:"Weight"`
	EnableClientIPPreservation string `name:"EnableClientIPPreservation"`
	EnableProxyProtocol        string `name:"EnableProxyProtocol"`
}

CreateEndpointGroupEndpointConfigurations is a repeated param struct in CreateEndpointGroupRequest

type CreateEndpointGroupRequest 

type CreateEndpointGroupRequest struct {
	*requests.RpcRequest
	ClientToken                string                                       `position:"Query" name:"ClientToken"`
	HealthCheckIntervalSeconds requests.Integer                             `position:"Query" name:"HealthCheckIntervalSeconds"`
	Description                string                                       `position:"Query" name:"Description"`
	HealthCheckProtocol        string                                       `position:"Query" name:"HealthCheckProtocol"`
	ListenerId                 string                                       `position:"Query" name:"ListenerId"`
	HealthCheckPath            string                                       `position:"Query" name:"HealthCheckPath"`
	EndpointConfigurations     *[]CreateEndpointGroupEndpointConfigurations `position:"Query" name:"EndpointConfigurations"  type:"Repeated"`
	AcceleratorId              string                                       `position:"Query" name:"AcceleratorId"`
	TrafficPercentage          requests.Integer                             `position:"Query" name:"TrafficPercentage"`
	HealthCheckPort            requests.Integer                             `position:"Query" name:"HealthCheckPort"`
	ThresholdCount             requests.Integer                             `position:"Query" name:"ThresholdCount"`
	EndpointGroupRegion        string                                       `position:"Query" name:"EndpointGroupRegion"`
	Name                       string                                       `position:"Query" name:"Name"`
}

CreateEndpointGroupRequest is the request struct for api CreateEndpointGroup

func CreateCreateEndpointGroupRequest 

func CreateCreateEndpointGroupRequest() (request *CreateEndpointGroupRequest)

CreateCreateEndpointGroupRequest creates a request to invoke CreateEndpointGroup API

type CreateEndpointGroupResponse 

type CreateEndpointGroupResponse struct {
	*responses.BaseResponse
	EndpointGroupId string `json:"EndpointGroupId" xml:"EndpointGroupId"`
	RequestId       string `json:"RequestId" xml:"RequestId"`
}

CreateEndpointGroupResponse is the response struct for api CreateEndpointGroup

func CreateCreateEndpointGroupResponse 

func CreateCreateEndpointGroupResponse() (response *CreateEndpointGroupResponse)

CreateCreateEndpointGroupResponse creates a response to parse from CreateEndpointGroup response

type CreateIpSetsAccelerateRegion 

type CreateIpSetsAccelerateRegion struct {
	AccelerateRegionId string `name:"AccelerateRegionId"`
	Bandwidth          string `name:"Bandwidth"`
	IpVersion          string `name:"IpVersion"`
}

CreateIpSetsAccelerateRegion is a repeated param struct in CreateIpSetsRequest

type CreateIpSetsRequest 

type CreateIpSetsRequest struct {
	*requests.RpcRequest
	ClientToken      string                          `position:"Query" name:"ClientToken"`
	AcceleratorId    string                          `position:"Query" name:"AcceleratorId"`
	AccelerateRegion *[]CreateIpSetsAccelerateRegion `position:"Query" name:"AccelerateRegion"  type:"Repeated"`
}

CreateIpSetsRequest is the request struct for api CreateIpSets

func CreateCreateIpSetsRequest 

func CreateCreateIpSetsRequest() (request *CreateIpSetsRequest)

CreateCreateIpSetsRequest creates a request to invoke CreateIpSets API

type CreateIpSetsResponse 

type CreateIpSetsResponse struct {
	*responses.BaseResponse
	AcceleratorId string    `json:"AcceleratorId" xml:"AcceleratorId"`
	RequestId     string    `json:"RequestId" xml:"RequestId"`
	IpSets        []GaIpSet `json:"IpSets" xml:"IpSets"`
}

CreateIpSetsResponse is the response struct for api CreateIpSets

func CreateCreateIpSetsResponse 

func CreateCreateIpSetsResponse() (response *CreateIpSetsResponse)

CreateCreateIpSetsResponse creates a response to parse from CreateIpSets response

type CreateListenerCertificates 

type CreateListenerCertificates struct {
	Id string `name:"Id"`
}

CreateListenerCertificates is a repeated param struct in CreateListenerRequest

type CreateListenerPortRanges 

type CreateListenerPortRanges struct {
	FromPort string `name:"FromPort"`
	ToPort   string `name:"ToPort"`
}

CreateListenerPortRanges is a repeated param struct in CreateListenerRequest

type CreateListenerRequest 

type CreateListenerRequest struct {
	*requests.RpcRequest
	ClientToken    string                        `position:"Query" name:"ClientToken"`
	Description    string                        `position:"Query" name:"Description"`
	BackendPorts   *[]CreateListenerString       `position:"Query" name:"BackendPorts"  type:"Repeated"`
	Protocol       string                        `position:"Query" name:"Protocol"`
	AcceleratorId  string                        `position:"Query" name:"AcceleratorId"`
	PortRanges     *[]CreateListenerPortRanges   `position:"Query" name:"PortRanges"  type:"Repeated"`
	ProxyProtocol  requests.Boolean              `position:"Query" name:"ProxyProtocol"`
	Certificates   *[]CreateListenerCertificates `position:"Query" name:"Certificates"  type:"Repeated"`
	Name           string                        `position:"Query" name:"Name"`
	ClientAffinity string                        `position:"Query" name:"ClientAffinity"`
}

CreateListenerRequest is the request struct for api CreateListener

func CreateCreateListenerRequest 

func CreateCreateListenerRequest() (request *CreateListenerRequest)

CreateCreateListenerRequest creates a request to invoke CreateListener API

type CreateListenerResponse 

type CreateListenerResponse struct {
	*responses.BaseResponse
	ListenerId string `json:"ListenerId" xml:"ListenerId"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

CreateListenerResponse is the response struct for api CreateListener

func CreateCreateListenerResponse 

func CreateCreateListenerResponse() (response *CreateListenerResponse)

CreateCreateListenerResponse creates a response to parse from CreateListener response

type CreateListenerString 

type CreateListenerString struct {
	FromPort string `name:"FromPort"`
	ToPort   string `name:"ToPort"`
}

CreateListenerString is a repeated param struct in CreateListenerRequest

type CrossDomainBandwidthPackage 

type CrossDomainBandwidthPackage struct {
	Bandwidth  int    `json:"Bandwidth" xml:"Bandwidth"`
	InstanceId string `json:"InstanceId" xml:"InstanceId"`
}

CrossDomainBandwidthPackage is a nested struct in ga response

type DeleteAcceleratorRequest 

type DeleteAcceleratorRequest struct {
	*requests.RpcRequest
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

DeleteAcceleratorRequest is the request struct for api DeleteAccelerator

func CreateDeleteAcceleratorRequest 

func CreateDeleteAcceleratorRequest() (request *DeleteAcceleratorRequest)

CreateDeleteAcceleratorRequest creates a request to invoke DeleteAccelerator API

type DeleteAcceleratorResponse 

type DeleteAcceleratorResponse struct {
	*responses.BaseResponse
	RequestId     string `json:"RequestId" xml:"RequestId"`
	AcceleratorId string `json:"AcceleratorId" xml:"AcceleratorId"`
}

DeleteAcceleratorResponse is the response struct for api DeleteAccelerator

func CreateDeleteAcceleratorResponse 

func CreateDeleteAcceleratorResponse() (response *DeleteAcceleratorResponse)

CreateDeleteAcceleratorResponse creates a response to parse from DeleteAccelerator response

type DeleteBandwidthPackageRequest 

type DeleteBandwidthPackageRequest struct {
	*requests.RpcRequest
	BandwidthPackageId string `position:"Query" name:"BandwidthPackageId"`
	ClientToken        string `position:"Query" name:"ClientToken"`
}

DeleteBandwidthPackageRequest is the request struct for api DeleteBandwidthPackage

func CreateDeleteBandwidthPackageRequest 

func CreateDeleteBandwidthPackageRequest() (request *DeleteBandwidthPackageRequest)

CreateDeleteBandwidthPackageRequest creates a request to invoke DeleteBandwidthPackage API

type DeleteBandwidthPackageResponse 

type DeleteBandwidthPackageResponse struct {
	*responses.BaseResponse
	RequestId          string `json:"RequestId" xml:"RequestId"`
	BandwidthPackageId string `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
}

DeleteBandwidthPackageResponse is the response struct for api DeleteBandwidthPackage

func CreateDeleteBandwidthPackageResponse 

func CreateDeleteBandwidthPackageResponse() (response *DeleteBandwidthPackageResponse)

CreateDeleteBandwidthPackageResponse creates a response to parse from DeleteBandwidthPackage response

type DeleteEndpointGroupRequest 

type DeleteEndpointGroupRequest struct {
	*requests.RpcRequest
	ClientToken     string `position:"Query" name:"ClientToken"`
	AcceleratorId   string `position:"Query" name:"AcceleratorId"`
	EndpointGroupId string `position:"Query" name:"EndpointGroupId"`
}

DeleteEndpointGroupRequest is the request struct for api DeleteEndpointGroup

func CreateDeleteEndpointGroupRequest 

func CreateDeleteEndpointGroupRequest() (request *DeleteEndpointGroupRequest)

CreateDeleteEndpointGroupRequest creates a request to invoke DeleteEndpointGroup API

type DeleteEndpointGroupResponse 

type DeleteEndpointGroupResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteEndpointGroupResponse is the response struct for api DeleteEndpointGroup

func CreateDeleteEndpointGroupResponse 

func CreateDeleteEndpointGroupResponse() (response *DeleteEndpointGroupResponse)

CreateDeleteEndpointGroupResponse creates a response to parse from DeleteEndpointGroup response

type DeleteIpSetRequest 

type DeleteIpSetRequest struct {
	*requests.RpcRequest
	ClientToken   string `position:"Query" name:"ClientToken"`
	IpSetId       string `position:"Query" name:"IpSetId"`
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

DeleteIpSetRequest is the request struct for api DeleteIpSet

func CreateDeleteIpSetRequest 

func CreateDeleteIpSetRequest() (request *DeleteIpSetRequest)

CreateDeleteIpSetRequest creates a request to invoke DeleteIpSet API

type DeleteIpSetResponse 

type DeleteIpSetResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteIpSetResponse is the response struct for api DeleteIpSet

func CreateDeleteIpSetResponse 

func CreateDeleteIpSetResponse() (response *DeleteIpSetResponse)

CreateDeleteIpSetResponse creates a response to parse from DeleteIpSet response

type DeleteIpSetsRequest 

type DeleteIpSetsRequest struct {
	*requests.RpcRequest
	IpSetIds *[]string `position:"Query" name:"IpSetIds"  type:"Repeated"`
}

DeleteIpSetsRequest is the request struct for api DeleteIpSets

func CreateDeleteIpSetsRequest 

func CreateDeleteIpSetsRequest() (request *DeleteIpSetsRequest)

CreateDeleteIpSetsRequest creates a request to invoke DeleteIpSets API

type DeleteIpSetsResponse 

type DeleteIpSetsResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteIpSetsResponse is the response struct for api DeleteIpSets

func CreateDeleteIpSetsResponse 

func CreateDeleteIpSetsResponse() (response *DeleteIpSetsResponse)

CreateDeleteIpSetsResponse creates a response to parse from DeleteIpSets response

type DeleteListenerRequest 

type DeleteListenerRequest struct {
	*requests.RpcRequest
	ClientToken   string `position:"Query" name:"ClientToken"`
	ListenerId    string `position:"Query" name:"ListenerId"`
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

DeleteListenerRequest is the request struct for api DeleteListener

func CreateDeleteListenerRequest 

func CreateDeleteListenerRequest() (request *DeleteListenerRequest)

CreateDeleteListenerRequest creates a request to invoke DeleteListener API

type DeleteListenerResponse 

type DeleteListenerResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

DeleteListenerResponse is the response struct for api DeleteListener

func CreateDeleteListenerResponse 

func CreateDeleteListenerResponse() (response *DeleteListenerResponse)

CreateDeleteListenerResponse creates a response to parse from DeleteListener response

type DescribeAcceleratorRequest 

type DescribeAcceleratorRequest struct {
	*requests.RpcRequest
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

DescribeAcceleratorRequest is the request struct for api DescribeAccelerator

func CreateDescribeAcceleratorRequest 

func CreateDescribeAcceleratorRequest() (request *DescribeAcceleratorRequest)

CreateDescribeAcceleratorRequest creates a request to invoke DescribeAccelerator API

type DescribeAcceleratorResponse 

type DescribeAcceleratorResponse struct {
	*responses.BaseResponse
	RequestId                   string                      `json:"RequestId" xml:"RequestId"`
	AcceleratorId               string                      `json:"AcceleratorId" xml:"AcceleratorId"`
	Name                        string                      `json:"Name" xml:"Name"`
	Description                 string                      `json:"Description" xml:"Description"`
	InstanceChargeType          string                      `json:"InstanceChargeType" xml:"InstanceChargeType"`
	ExpiredTime                 int64                       `json:"ExpiredTime" xml:"ExpiredTime"`
	CenId                       string                      `json:"CenId" xml:"CenId"`
	State                       string                      `json:"State" xml:"State"`
	DnsName                     string                      `json:"DnsName" xml:"DnsName"`
	CreateTime                  int64                       `json:"CreateTime" xml:"CreateTime"`
	Spec                        string                      `json:"Spec" xml:"Spec"`
	RegionId                    string                      `json:"RegionId" xml:"RegionId"`
	DdosId                      string                      `json:"DdosId" xml:"DdosId"`
	SecondDnsName               string                      `json:"SecondDnsName" xml:"SecondDnsName"`
	BasicBandwidthPackage       BasicBandwidthPackage       `json:"BasicBandwidthPackage" xml:"BasicBandwidthPackage"`
	CrossDomainBandwidthPackage CrossDomainBandwidthPackage `json:"CrossDomainBandwidthPackage" xml:"CrossDomainBandwidthPackage"`
}

DescribeAcceleratorResponse is the response struct for api DescribeAccelerator

func CreateDescribeAcceleratorResponse 

func CreateDescribeAcceleratorResponse() (response *DescribeAcceleratorResponse)

CreateDescribeAcceleratorResponse creates a response to parse from DescribeAccelerator response

type DescribeBandwidthPackageRequest 

type DescribeBandwidthPackageRequest struct {
	*requests.RpcRequest
	BandwidthPackageId string `position:"Query" name:"BandwidthPackageId"`
}

DescribeBandwidthPackageRequest is the request struct for api DescribeBandwidthPackage

func CreateDescribeBandwidthPackageRequest 

func CreateDescribeBandwidthPackageRequest() (request *DescribeBandwidthPackageRequest)

CreateDescribeBandwidthPackageRequest creates a request to invoke DescribeBandwidthPackage API

type DescribeBandwidthPackageResponse 

type DescribeBandwidthPackageResponse struct {
	*responses.BaseResponse
	RequestId              string   `json:"RequestId" xml:"RequestId"`
	BandwidthPackageId     string   `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	Name                   string   `json:"Name" xml:"Name"`
	Description            string   `json:"Description" xml:"Description"`
	State                  string   `json:"State" xml:"State"`
	Bandwidth              int      `json:"Bandwidth" xml:"Bandwidth"`
	ChargeType             string   `json:"ChargeType" xml:"ChargeType"`
	ExpiredTime            string   `json:"ExpiredTime" xml:"ExpiredTime"`
	CreateTime             string   `json:"CreateTime" xml:"CreateTime"`
	RegionId               string   `json:"RegionId" xml:"RegionId"`
	Type                   string   `json:"Type" xml:"Type"`
	BandwidthType          string   `json:"BandwidthType" xml:"BandwidthType"`
	CbnGeographicRegionIdA string   `json:"CbnGeographicRegionIdA" xml:"CbnGeographicRegionIdA"`
	CbnGeographicRegionIdB string   `json:"CbnGeographicRegionIdB" xml:"CbnGeographicRegionIdB"`
	BillingType            string   `json:"BillingType" xml:"BillingType"`
	Accelerators           []string `json:"Accelerators" xml:"Accelerators"`
}

DescribeBandwidthPackageResponse is the response struct for api DescribeBandwidthPackage

func CreateDescribeBandwidthPackageResponse 

func CreateDescribeBandwidthPackageResponse() (response *DescribeBandwidthPackageResponse)

CreateDescribeBandwidthPackageResponse creates a response to parse from DescribeBandwidthPackage response

type DescribeEndpointGroupRequest 

type DescribeEndpointGroupRequest struct {
	*requests.RpcRequest
	EndpointGroupId string `position:"Query" name:"EndpointGroupId"`
}

DescribeEndpointGroupRequest is the request struct for api DescribeEndpointGroup

func CreateDescribeEndpointGroupRequest 

func CreateDescribeEndpointGroupRequest() (request *DescribeEndpointGroupRequest)

CreateDescribeEndpointGroupRequest creates a request to invoke DescribeEndpointGroup API

type DescribeEndpointGroupResponse 

type DescribeEndpointGroupResponse struct {
	*responses.BaseResponse
	Description                string                       `json:"Description" xml:"Description"`
	EndpointGroupId            string                       `json:"EndpointGroupId" xml:"EndpointGroupId"`
	EndpointGroupRegion        string                       `json:"EndpointGroupRegion" xml:"EndpointGroupRegion"`
	HealthCheckIntervalSeconds int                          `json:"HealthCheckIntervalSeconds" xml:"HealthCheckIntervalSeconds"`
	HealthCheckPath            string                       `json:"HealthCheckPath" xml:"HealthCheckPath"`
	HealthCheckPort            int                          `json:"HealthCheckPort" xml:"HealthCheckPort"`
	HealthCheckProtocol        string                       `json:"HealthCheckProtocol" xml:"HealthCheckProtocol"`
	ListenerId                 string                       `json:"ListenerId" xml:"ListenerId"`
	Name                       string                       `json:"Name" xml:"Name"`
	RequestId                  string                       `json:"RequestId" xml:"RequestId"`
	State                      string                       `json:"State" xml:"State"`
	ThresholdCount             int                          `json:"ThresholdCount" xml:"ThresholdCount"`
	TotalCount                 int                          `json:"TotalCount" xml:"TotalCount"`
	TrafficPercentage          int                          `json:"TrafficPercentage" xml:"TrafficPercentage"`
	EndpointConfigurations     []EndpointConfigurationsItem `json:"EndpointConfigurations" xml:"EndpointConfigurations"`
}

DescribeEndpointGroupResponse is the response struct for api DescribeEndpointGroup

func CreateDescribeEndpointGroupResponse 

func CreateDescribeEndpointGroupResponse() (response *DescribeEndpointGroupResponse)

CreateDescribeEndpointGroupResponse creates a response to parse from DescribeEndpointGroup response

type DescribeIpSetRequest 

type DescribeIpSetRequest struct {
	*requests.RpcRequest
	IpSetId string `position:"Query" name:"IpSetId"`
}

DescribeIpSetRequest is the request struct for api DescribeIpSet

func CreateDescribeIpSetRequest 

func CreateDescribeIpSetRequest() (request *DescribeIpSetRequest)

CreateDescribeIpSetRequest creates a request to invoke DescribeIpSet API

type DescribeIpSetResponse 

type DescribeIpSetResponse struct {
	*responses.BaseResponse
	AccelerateRegionId string   `json:"AccelerateRegionId" xml:"AccelerateRegionId"`
	Bandwidth          int      `json:"Bandwidth" xml:"Bandwidth"`
	IpSetId            string   `json:"IpSetId" xml:"IpSetId"`
	RequestId          string   `json:"RequestId" xml:"RequestId"`
	State              string   `json:"State" xml:"State"`
	IpVersion          string   `json:"IpVersion" xml:"IpVersion"`
	IpAddressList      []string `json:"IpAddressList" xml:"IpAddressList"`
}

DescribeIpSetResponse is the response struct for api DescribeIpSet

func CreateDescribeIpSetResponse 

func CreateDescribeIpSetResponse() (response *DescribeIpSetResponse)

CreateDescribeIpSetResponse creates a response to parse from DescribeIpSet response

type DescribeListenerRequest 

type DescribeListenerRequest struct {
	*requests.RpcRequest
	ListenerId string `position:"Query" name:"ListenerId"`
}

DescribeListenerRequest is the request struct for api DescribeListener

func CreateDescribeListenerRequest 

func CreateDescribeListenerRequest() (request *DescribeListenerRequest)

CreateDescribeListenerRequest creates a request to invoke DescribeListener API

type DescribeListenerResponse 

type DescribeListenerResponse struct {
	*responses.BaseResponse
	ClientAffinity string           `json:"ClientAffinity" xml:"ClientAffinity"`
	CreateTime     string           `json:"CreateTime" xml:"CreateTime"`
	Description    string           `json:"Description" xml:"Description"`
	ListenerId     string           `json:"ListenerId" xml:"ListenerId"`
	Name           string           `json:"Name" xml:"Name"`
	Protocol       string           `json:"Protocol" xml:"Protocol"`
	RequestId      string           `json:"RequestId" xml:"RequestId"`
	State          string           `json:"State" xml:"State"`
	PortRanges     []PortRangesItem `json:"PortRanges" xml:"PortRanges"`
	Certificates   []Certificate    `json:"Certificates" xml:"Certificates"`
	BackendPorts   []BackendPort    `json:"BackendPorts" xml:"BackendPorts"`
}

DescribeListenerResponse is the response struct for api DescribeListener

func CreateDescribeListenerResponse 

func CreateDescribeListenerResponse() (response *DescribeListenerResponse)

CreateDescribeListenerResponse creates a response to parse from DescribeListener response

type DescribeRegionsRequest 

type DescribeRegionsRequest struct {
	*requests.RpcRequest
}

DescribeRegionsRequest is the request struct for api DescribeRegions

func CreateDescribeRegionsRequest 

func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)

CreateDescribeRegionsRequest creates a request to invoke DescribeRegions API

type DescribeRegionsResponse 

type DescribeRegionsResponse struct {
	*responses.BaseResponse
	RequestId string        `json:"RequestId" xml:"RequestId"`
	Regions   []RegionsItem `json:"Regions" xml:"Regions"`
}

DescribeRegionsResponse is the response struct for api DescribeRegions

func CreateDescribeRegionsResponse 

func CreateDescribeRegionsResponse() (response *DescribeRegionsResponse)

CreateDescribeRegionsResponse creates a response to parse from DescribeRegions response

type DetachDdosFromAcceleratorRequest 

type DetachDdosFromAcceleratorRequest struct {
	*requests.RpcRequest
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

DetachDdosFromAcceleratorRequest is the request struct for api DetachDdosFromAccelerator

func CreateDetachDdosFromAcceleratorRequest 

func CreateDetachDdosFromAcceleratorRequest() (request *DetachDdosFromAcceleratorRequest)

CreateDetachDdosFromAcceleratorRequest creates a request to invoke DetachDdosFromAccelerator API

type DetachDdosFromAcceleratorResponse 

type DetachDdosFromAcceleratorResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	DdosId    string `json:"DdosId" xml:"DdosId"`
}

DetachDdosFromAcceleratorResponse is the response struct for api DetachDdosFromAccelerator

func CreateDetachDdosFromAcceleratorResponse 

func CreateDetachDdosFromAcceleratorResponse() (response *DetachDdosFromAcceleratorResponse)

CreateDetachDdosFromAcceleratorResponse creates a response to parse from DetachDdosFromAccelerator response

type EndpointConfigurationsInDescribeEndpointGroup 

type EndpointConfigurationsInDescribeEndpointGroup struct {
	EndpointConfigurationsItem []EndpointConfigurationsItem `json:"EndpointConfigurations" xml:"EndpointConfigurations"`
}

EndpointConfigurationsInDescribeEndpointGroup is a nested struct in ga response

type EndpointConfigurationsInListEndpointGroups 

type EndpointConfigurationsInListEndpointGroups struct {
	EndpointConfigurationsItem []EndpointConfigurationsItem `json:"EndpointConfigurations" xml:"EndpointConfigurations"`
}

EndpointConfigurationsInListEndpointGroups is a nested struct in ga response

type EndpointConfigurationsItem 

type EndpointConfigurationsItem struct {
	Endpoint                   string `json:"Endpoint" xml:"Endpoint"`
	EnableProxyProtocol        bool   `json:"EnableProxyProtocol" xml:"EnableProxyProtocol"`
	ProbeProtocol              string `json:"ProbeProtocol" xml:"ProbeProtocol"`
	EnableClientIPPreservation bool   `json:"EnableClientIPPreservation" xml:"EnableClientIPPreservation"`
	Weight                     int    `json:"Weight" xml:"Weight"`
	ProbePort                  int    `json:"ProbePort" xml:"ProbePort"`
	Type                       string `json:"Type" xml:"Type"`
}

EndpointConfigurationsItem is a nested struct in ga response

type EndpointGroupIpList 

type EndpointGroupIpList struct {
	EndpointGroupIpList []string `json:"EndpointGroupIpList" xml:"EndpointGroupIpList"`
}

EndpointGroupIpList is a nested struct in ga response

type EndpointGroups 

type EndpointGroups struct {
	EndpointGroupsItem []EndpointGroupsItem `json:"EndpointGroups" xml:"EndpointGroups"`
}

EndpointGroups is a nested struct in ga response

type EndpointGroupsItem 

type EndpointGroupsItem struct {
	Description                string                       `json:"Description" xml:"Description"`
	EndpointGroupId            string                       `json:"EndpointGroupId" xml:"EndpointGroupId"`
	EndpointGroupRegion        string                       `json:"EndpointGroupRegion" xml:"EndpointGroupRegion"`
	HealthCheckIntervalSeconds int                          `json:"HealthCheckIntervalSeconds" xml:"HealthCheckIntervalSeconds"`
	HealthCheckPath            string                       `json:"HealthCheckPath" xml:"HealthCheckPath"`
	HealthCheckPort            int                          `json:"HealthCheckPort" xml:"HealthCheckPort"`
	HealthCheckProtocol        string                       `json:"HealthCheckProtocol" xml:"HealthCheckProtocol"`
	ListenerId                 string                       `json:"ListenerId" xml:"ListenerId"`
	Name                       string                       `json:"Name" xml:"Name"`
	State                      string                       `json:"State" xml:"State"`
	ThresholdCount             int                          `json:"ThresholdCount" xml:"ThresholdCount"`
	TrafficPercentage          int                          `json:"TrafficPercentage" xml:"TrafficPercentage"`
	EndpointGroupIpList        []string                     `json:"EndpointGroupIpList" xml:"EndpointGroupIpList"`
	EndpointConfigurations     []EndpointConfigurationsItem `json:"EndpointConfigurations" xml:"EndpointConfigurations"`
}

EndpointGroupsItem is a nested struct in ga response

type GaIpSet 

type GaIpSet struct {
	AccelerateRegionId string   `json:"AccelerateRegionId" xml:"AccelerateRegionId"`
	Bandwidth          int      `json:"Bandwidth" xml:"Bandwidth"`
	IpSetId            string   `json:"IpSetId" xml:"IpSetId"`
	IpList             []string `json:"IpList" xml:"IpList"`
}

GaIpSet is a nested struct in ga response

type IpAddressListInDescribeIpSet 

type IpAddressListInDescribeIpSet struct {
	IpAddressList []string `json:"IpAddressList" xml:"IpAddressList"`
}

IpAddressListInDescribeIpSet is a nested struct in ga response

type IpAddressListInListIpSets 

type IpAddressListInListIpSets struct {
	IpAddressList []string `json:"IpAddressList" xml:"IpAddressList"`
}

IpAddressListInListIpSets is a nested struct in ga response

type IpList 

type IpList struct {
	IpList []string `json:"IpList" xml:"IpList"`
}

IpList is a nested struct in ga response

type IpSetsInCreateIpSets 

type IpSetsInCreateIpSets struct {
	GaIpSet []GaIpSet `json:"GaIpSet" xml:"GaIpSet"`
}

IpSetsInCreateIpSets is a nested struct in ga response

type IpSetsInListIpSets 

type IpSetsInListIpSets struct {
	IpSetsItem []IpSetsItem `json:"IpSets" xml:"IpSets"`
}

IpSetsInListIpSets is a nested struct in ga response

type IpSetsItem 

type IpSetsItem struct {
	AccelerateRegionId string   `json:"AccelerateRegionId" xml:"AccelerateRegionId"`
	Bandwidth          int      `json:"Bandwidth" xml:"Bandwidth"`
	IpSetId            string   `json:"IpSetId" xml:"IpSetId"`
	State              string   `json:"State" xml:"State"`
	IpVersion          string   `json:"IpVersion" xml:"IpVersion"`
	IpAddressList      []string `json:"IpAddressList" xml:"IpAddressList"`
}

IpSetsItem is a nested struct in ga response

type ListAccelerateAreasRequest 

type ListAccelerateAreasRequest struct {
	*requests.RpcRequest
}

ListAccelerateAreasRequest is the request struct for api ListAccelerateAreas

func CreateListAccelerateAreasRequest 

func CreateListAccelerateAreasRequest() (request *ListAccelerateAreasRequest)

CreateListAccelerateAreasRequest creates a request to invoke ListAccelerateAreas API

type ListAccelerateAreasResponse 

type ListAccelerateAreasResponse struct {
	*responses.BaseResponse
	RequestId string      `json:"RequestId" xml:"RequestId"`
	Areas     []AreasItem `json:"Areas" xml:"Areas"`
}

ListAccelerateAreasResponse is the response struct for api ListAccelerateAreas

func CreateListAccelerateAreasResponse 

func CreateListAccelerateAreasResponse() (response *ListAccelerateAreasResponse)

CreateListAccelerateAreasResponse creates a response to parse from ListAccelerateAreas response

type ListAcceleratorsRequest 

type ListAcceleratorsRequest struct {
	*requests.RpcRequest
	PageNumber    requests.Integer `position:"Query" name:"PageNumber"`
	PageSize      requests.Integer `position:"Query" name:"PageSize"`
	AcceleratorId string           `position:"Query" name:"AcceleratorId"`
}

ListAcceleratorsRequest is the request struct for api ListAccelerators

func CreateListAcceleratorsRequest 

func CreateListAcceleratorsRequest() (request *ListAcceleratorsRequest)

CreateListAcceleratorsRequest creates a request to invoke ListAccelerators API

type ListAcceleratorsResponse 

type ListAcceleratorsResponse struct {
	*responses.BaseResponse
	RequestId    string             `json:"RequestId" xml:"RequestId"`
	TotalCount   int                `json:"TotalCount" xml:"TotalCount"`
	PageNumber   int                `json:"PageNumber" xml:"PageNumber"`
	PageSize     int                `json:"PageSize" xml:"PageSize"`
	Accelerators []AcceleratorsItem `json:"Accelerators" xml:"Accelerators"`
}

ListAcceleratorsResponse is the response struct for api ListAccelerators

func CreateListAcceleratorsResponse 

func CreateListAcceleratorsResponse() (response *ListAcceleratorsResponse)

CreateListAcceleratorsResponse creates a response to parse from ListAccelerators response

type ListAvailableAccelerateAreasRequest 

type ListAvailableAccelerateAreasRequest struct {
	*requests.RpcRequest
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

ListAvailableAccelerateAreasRequest is the request struct for api ListAvailableAccelerateAreas

func CreateListAvailableAccelerateAreasRequest 

func CreateListAvailableAccelerateAreasRequest() (request *ListAvailableAccelerateAreasRequest)

CreateListAvailableAccelerateAreasRequest creates a request to invoke ListAvailableAccelerateAreas API

type ListAvailableAccelerateAreasResponse 

type ListAvailableAccelerateAreasResponse struct {
	*responses.BaseResponse
	RequestId string      `json:"RequestId" xml:"RequestId"`
	Areas     []AreasItem `json:"Areas" xml:"Areas"`
}

ListAvailableAccelerateAreasResponse is the response struct for api ListAvailableAccelerateAreas

func CreateListAvailableAccelerateAreasResponse 

func CreateListAvailableAccelerateAreasResponse() (response *ListAvailableAccelerateAreasResponse)

CreateListAvailableAccelerateAreasResponse creates a response to parse from ListAvailableAccelerateAreas response

type ListAvailableBusiRegionsRequest 

type ListAvailableBusiRegionsRequest struct {
	*requests.RpcRequest
	AcceleratorId string `position:"Query" name:"AcceleratorId"`
}

ListAvailableBusiRegionsRequest is the request struct for api ListAvailableBusiRegions

func CreateListAvailableBusiRegionsRequest 

func CreateListAvailableBusiRegionsRequest() (request *ListAvailableBusiRegionsRequest)

CreateListAvailableBusiRegionsRequest creates a request to invoke ListAvailableBusiRegions API

type ListAvailableBusiRegionsResponse 

type ListAvailableBusiRegionsResponse struct {
	*responses.BaseResponse
	RequestId string        `json:"RequestId" xml:"RequestId"`
	Regions   []RegionsItem `json:"Regions" xml:"Regions"`
}

ListAvailableBusiRegionsResponse is the response struct for api ListAvailableBusiRegions

func CreateListAvailableBusiRegionsResponse 

func CreateListAvailableBusiRegionsResponse() (response *ListAvailableBusiRegionsResponse)

CreateListAvailableBusiRegionsResponse creates a response to parse from ListAvailableBusiRegions response

type ListBandwidthPackagesRequest 

type ListBandwidthPackagesRequest struct {
	*requests.RpcRequest
	BandwidthPackageId string           `position:"Query" name:"BandwidthPackageId"`
	Type               string           `position:"Query" name:"Type"`
	PageNumber         requests.Integer `position:"Query" name:"PageNumber"`
	PageSize           requests.Integer `position:"Query" name:"PageSize"`
	State              string           `position:"Query" name:"State"`
}

ListBandwidthPackagesRequest is the request struct for api ListBandwidthPackages

func CreateListBandwidthPackagesRequest 

func CreateListBandwidthPackagesRequest() (request *ListBandwidthPackagesRequest)

CreateListBandwidthPackagesRequest creates a request to invoke ListBandwidthPackages API

type ListBandwidthPackagesResponse 

type ListBandwidthPackagesResponse struct {
	*responses.BaseResponse
	RequestId         string             `json:"RequestId" xml:"RequestId"`
	TotalCount        int                `json:"TotalCount" xml:"TotalCount"`
	PageNumber        int                `json:"PageNumber" xml:"PageNumber"`
	PageSize          int                `json:"PageSize" xml:"PageSize"`
	BandwidthPackages []BandwidthPackage `json:"BandwidthPackages" xml:"BandwidthPackages"`
}

ListBandwidthPackagesResponse is the response struct for api ListBandwidthPackages

func CreateListBandwidthPackagesResponse 

func CreateListBandwidthPackagesResponse() (response *ListBandwidthPackagesResponse)

CreateListBandwidthPackagesResponse creates a response to parse from ListBandwidthPackages response

type ListBandwidthackagesRequest 

type ListBandwidthackagesRequest struct {
	*requests.RpcRequest
	PageNumber requests.Integer `position:"Query" name:"PageNumber"`
	PageSize   requests.Integer `position:"Query" name:"PageSize"`
}

ListBandwidthackagesRequest is the request struct for api ListBandwidthackages

func CreateListBandwidthackagesRequest 

func CreateListBandwidthackagesRequest() (request *ListBandwidthackagesRequest)

CreateListBandwidthackagesRequest creates a request to invoke ListBandwidthackages API

type ListBandwidthackagesResponse 

type ListBandwidthackagesResponse struct {
	*responses.BaseResponse
	RequestId         string             `json:"RequestId" xml:"RequestId"`
	TotalCount        int                `json:"TotalCount" xml:"TotalCount"`
	PageNumber        int                `json:"PageNumber" xml:"PageNumber"`
	PageSize          int                `json:"PageSize" xml:"PageSize"`
	BandwidthPackages []BandwidthPackage `json:"BandwidthPackages" xml:"BandwidthPackages"`
}

ListBandwidthackagesResponse is the response struct for api ListBandwidthackages

func CreateListBandwidthackagesResponse 

func CreateListBandwidthackagesResponse() (response *ListBandwidthackagesResponse)

CreateListBandwidthackagesResponse creates a response to parse from ListBandwidthackages response

type ListBusiRegionsRequest 

type ListBusiRegionsRequest struct {
	*requests.RpcRequest
}

ListBusiRegionsRequest is the request struct for api ListBusiRegions

func CreateListBusiRegionsRequest 

func CreateListBusiRegionsRequest() (request *ListBusiRegionsRequest)

CreateListBusiRegionsRequest creates a request to invoke ListBusiRegions API

type ListBusiRegionsResponse 

type ListBusiRegionsResponse struct {
	*responses.BaseResponse
	RequestId string        `json:"RequestId" xml:"RequestId"`
	Regions   []RegionsItem `json:"Regions" xml:"Regions"`
}

ListBusiRegionsResponse is the response struct for api ListBusiRegions

func CreateListBusiRegionsResponse 

func CreateListBusiRegionsResponse() (response *ListBusiRegionsResponse)

CreateListBusiRegionsResponse creates a response to parse from ListBusiRegions response

type ListEndpointGroupsRequest 

type ListEndpointGroupsRequest struct {
	*requests.RpcRequest
	PageNumber    requests.Integer `position:"Query" name:"PageNumber"`
	ListenerId    string           `position:"Query" name:"ListenerId"`
	PageSize      requests.Integer `position:"Query" name:"PageSize"`
	AcceleratorId string           `position:"Query" name:"AcceleratorId"`
}

ListEndpointGroupsRequest is the request struct for api ListEndpointGroups

func CreateListEndpointGroupsRequest 

func CreateListEndpointGroupsRequest() (request *ListEndpointGroupsRequest)

CreateListEndpointGroupsRequest creates a request to invoke ListEndpointGroups API

type ListEndpointGroupsResponse 

type ListEndpointGroupsResponse struct {
	*responses.BaseResponse
	PageNumber     int                  `json:"PageNumber" xml:"PageNumber"`
	PageSize       int                  `json:"PageSize" xml:"PageSize"`
	RequestId      string               `json:"RequestId" xml:"RequestId"`
	TotalCount     int                  `json:"TotalCount" xml:"TotalCount"`
	EndpointGroups []EndpointGroupsItem `json:"EndpointGroups" xml:"EndpointGroups"`
}

ListEndpointGroupsResponse is the response struct for api ListEndpointGroups

func CreateListEndpointGroupsResponse 

func CreateListEndpointGroupsResponse() (response *ListEndpointGroupsResponse)

CreateListEndpointGroupsResponse creates a response to parse from ListEndpointGroups response

type ListIpSetsRequest 

type ListIpSetsRequest struct {
	*requests.RpcRequest
	PageNumber    requests.Integer `position:"Query" name:"PageNumber"`
	PageSize      requests.Integer `position:"Query" name:"PageSize"`
	AcceleratorId string           `position:"Query" name:"AcceleratorId"`
}

ListIpSetsRequest is the request struct for api ListIpSets

func CreateListIpSetsRequest 

func CreateListIpSetsRequest() (request *ListIpSetsRequest)

CreateListIpSetsRequest creates a request to invoke ListIpSets API

type ListIpSetsResponse 

type ListIpSetsResponse struct {
	*responses.BaseResponse
	PageNumber int          `json:"PageNumber" xml:"PageNumber"`
	PageSize   int          `json:"PageSize" xml:"PageSize"`
	RequestId  string       `json:"RequestId" xml:"RequestId"`
	TotalCount int          `json:"TotalCount" xml:"TotalCount"`
	IpSets     []IpSetsItem `json:"IpSets" xml:"IpSets"`
}

ListIpSetsResponse is the response struct for api ListIpSets

func CreateListIpSetsResponse 

func CreateListIpSetsResponse() (response *ListIpSetsResponse)

CreateListIpSetsResponse creates a response to parse from ListIpSets response

type ListListenersRequest 

type ListListenersRequest struct {
	*requests.RpcRequest
	PageNumber    requests.Integer `position:"Query" name:"PageNumber"`
	PageSize      requests.Integer `position:"Query" name:"PageSize"`
	AcceleratorId string           `position:"Query" name:"AcceleratorId"`
}

ListListenersRequest is the request struct for api ListListeners

func CreateListListenersRequest 

func CreateListListenersRequest() (request *ListListenersRequest)

CreateListListenersRequest creates a request to invoke ListListeners API

type ListListenersResponse 

type ListListenersResponse struct {
	*responses.BaseResponse
	PageNumber int             `json:"PageNumber" xml:"PageNumber"`
	PageSize   int             `json:"PageSize" xml:"PageSize"`
	RequestId  string          `json:"RequestId" xml:"RequestId"`
	TotalCount int             `json:"TotalCount" xml:"TotalCount"`
	Listeners  []ListenersItem `json:"Listeners" xml:"Listeners"`
}

ListListenersResponse is the response struct for api ListListeners

func CreateListListenersResponse 

func CreateListListenersResponse() (response *ListListenersResponse)

CreateListListenersResponse creates a response to parse from ListListeners response

type Listeners 

type Listeners struct {
	ListenersItem []ListenersItem `json:"Listeners" xml:"Listeners"`
}

Listeners is a nested struct in ga response

type ListenersItem 

type ListenersItem struct {
	ClientAffinity string           `json:"ClientAffinity" xml:"ClientAffinity"`
	CreateTime     int64            `json:"CreateTime" xml:"CreateTime"`
	Description    string           `json:"Description" xml:"Description"`
	ListenerId     string           `json:"ListenerId" xml:"ListenerId"`
	Name           string           `json:"Name" xml:"Name"`
	Protocol       string           `json:"Protocol" xml:"Protocol"`
	State          string           `json:"State" xml:"State"`
	ProxyProtocol  bool             `json:"ProxyProtocol" xml:"ProxyProtocol"`
	PortRanges     []PortRangesItem `json:"PortRanges" xml:"PortRanges"`
	Certificates   []Certificate    `json:"Certificates" xml:"Certificates"`
	BackendPorts   []BackendPort    `json:"BackendPorts" xml:"BackendPorts"`
}

ListenersItem is a nested struct in ga response

type PortRangesInDescribeListener 

type PortRangesInDescribeListener struct {
	PortRangesItem []PortRangesItem `json:"PortRanges" xml:"PortRanges"`
}

PortRangesInDescribeListener is a nested struct in ga response

type PortRangesInListListeners 

type PortRangesInListListeners struct {
	PortRangesItem []PortRangesItem `json:"PortRanges" xml:"PortRanges"`
}

PortRangesInListListeners is a nested struct in ga response

type PortRangesItem 

type PortRangesItem struct {
	FromPort int `json:"FromPort" xml:"FromPort"`
	ToPort   int `json:"ToPort" xml:"ToPort"`
}

PortRangesItem is a nested struct in ga response

type RegionListInListAccelerateAreas 

type RegionListInListAccelerateAreas struct {
	RegionListItem []RegionListItem `json:"RegionList" xml:"RegionList"`
}

RegionListInListAccelerateAreas is a nested struct in ga response

type RegionListInListAvailableAccelerateAreas 

type RegionListInListAvailableAccelerateAreas struct {
	RegionListItem []RegionListItem `json:"RegionList" xml:"RegionList"`
}

RegionListInListAvailableAccelerateAreas is a nested struct in ga response

type RegionListItem 

type RegionListItem struct {
	RegionId  string `json:"RegionId" xml:"RegionId"`
	LocalName string `json:"LocalName" xml:"LocalName"`
}

RegionListItem is a nested struct in ga response

type RegionsInDescribeRegions 

type RegionsInDescribeRegions struct {
	RegionsItem []RegionsItem `json:"Regions" xml:"Regions"`
}

RegionsInDescribeRegions is a nested struct in ga response

type RegionsInListAvailableBusiRegions 

type RegionsInListAvailableBusiRegions struct {
	RegionsItem []RegionsItem `json:"Regions" xml:"Regions"`
}

RegionsInListAvailableBusiRegions is a nested struct in ga response

type RegionsInListBusiRegions 

type RegionsInListBusiRegions struct {
	RegionsItem []RegionsItem `json:"Regions" xml:"Regions"`
}

RegionsInListBusiRegions is a nested struct in ga response

type RegionsItem 

type RegionsItem struct {
	RegionId  string `json:"RegionId" xml:"RegionId"`
	LocalName string `json:"LocalName" xml:"LocalName"`
}

RegionsItem is a nested struct in ga response

type ReplaceBandwidthPackageRequest 

type ReplaceBandwidthPackageRequest struct {
	*requests.RpcRequest
	BandwidthPackageId       string `position:"Query" name:"BandwidthPackageId"`
	TargetBandwidthPackageId string `position:"Query" name:"TargetBandwidthPackageId"`
}

ReplaceBandwidthPackageRequest is the request struct for api ReplaceBandwidthPackage

func CreateReplaceBandwidthPackageRequest 

func CreateReplaceBandwidthPackageRequest() (request *ReplaceBandwidthPackageRequest)

CreateReplaceBandwidthPackageRequest creates a request to invoke ReplaceBandwidthPackage API

type ReplaceBandwidthPackageResponse 

type ReplaceBandwidthPackageResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

ReplaceBandwidthPackageResponse is the response struct for api ReplaceBandwidthPackage

func CreateReplaceBandwidthPackageResponse 

func CreateReplaceBandwidthPackageResponse() (response *ReplaceBandwidthPackageResponse)

CreateReplaceBandwidthPackageResponse creates a response to parse from ReplaceBandwidthPackage response

type UpdateAcceleratorRequest 

type UpdateAcceleratorRequest struct {
	*requests.RpcRequest
	AutoPay           requests.Boolean `position:"Query" name:"AutoPay"`
	PromotionOptionNo string           `position:"Query" name:"PromotionOptionNo"`
	ClientToken       string           `position:"Query" name:"ClientToken"`
	Description       string           `position:"Query" name:"Description"`
	AutoUseCoupon     requests.Boolean `position:"Query" name:"AutoUseCoupon"`
	Spec              string           `position:"Query" name:"Spec"`
	Name              string           `position:"Query" name:"Name"`
	AcceleratorId     string           `position:"Query" name:"AcceleratorId"`
}

UpdateAcceleratorRequest is the request struct for api UpdateAccelerator

func CreateUpdateAcceleratorRequest 

func CreateUpdateAcceleratorRequest() (request *UpdateAcceleratorRequest)

CreateUpdateAcceleratorRequest creates a request to invoke UpdateAccelerator API

type UpdateAcceleratorResponse 

type UpdateAcceleratorResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateAcceleratorResponse is the response struct for api UpdateAccelerator

func CreateUpdateAcceleratorResponse 

func CreateUpdateAcceleratorResponse() (response *UpdateAcceleratorResponse)

CreateUpdateAcceleratorResponse creates a response to parse from UpdateAccelerator response

type UpdateBandwidthPackageRequest 

type UpdateBandwidthPackageRequest struct {
	*requests.RpcRequest
	BandwidthType      string           `position:"Query" name:"BandwidthType"`
	BandwidthPackageId string           `position:"Query" name:"BandwidthPackageId"`
	AutoPay            requests.Boolean `position:"Query" name:"AutoPay"`
	PromotionOptionNo  string           `position:"Query" name:"PromotionOptionNo"`
	Bandwidth          requests.Integer `position:"Query" name:"Bandwidth"`
	Description        string           `position:"Query" name:"Description"`
	AutoUseCoupon      requests.Boolean `position:"Query" name:"AutoUseCoupon"`
	Name               string           `position:"Query" name:"Name"`
}

UpdateBandwidthPackageRequest is the request struct for api UpdateBandwidthPackage

func CreateUpdateBandwidthPackageRequest 

func CreateUpdateBandwidthPackageRequest() (request *UpdateBandwidthPackageRequest)

CreateUpdateBandwidthPackageRequest creates a request to invoke UpdateBandwidthPackage API

type UpdateBandwidthPackageResponse 

type UpdateBandwidthPackageResponse struct {
	*responses.BaseResponse
	RequestId        string `json:"RequestId" xml:"RequestId"`
	BandwidthPackage string `json:"BandwidthPackage" xml:"BandwidthPackage"`
	Name             string `json:"Name" xml:"Name"`
	Description      string `json:"Description" xml:"Description"`
}

UpdateBandwidthPackageResponse is the response struct for api UpdateBandwidthPackage

func CreateUpdateBandwidthPackageResponse 

func CreateUpdateBandwidthPackageResponse() (response *UpdateBandwidthPackageResponse)

CreateUpdateBandwidthPackageResponse creates a response to parse from UpdateBandwidthPackage response

type UpdateEndpointGroupAttributeRequest 

type UpdateEndpointGroupAttributeRequest struct {
	*requests.RpcRequest
	ClientToken     string `position:"Query" name:"ClientToken"`
	Description     string `position:"Query" name:"Description"`
	Name            string `position:"Query" name:"Name"`
	EndpointGroupId string `position:"Query" name:"EndpointGroupId"`
}

UpdateEndpointGroupAttributeRequest is the request struct for api UpdateEndpointGroupAttribute

func CreateUpdateEndpointGroupAttributeRequest 

func CreateUpdateEndpointGroupAttributeRequest() (request *UpdateEndpointGroupAttributeRequest)

CreateUpdateEndpointGroupAttributeRequest creates a request to invoke UpdateEndpointGroupAttribute API

type UpdateEndpointGroupAttributeResponse 

type UpdateEndpointGroupAttributeResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateEndpointGroupAttributeResponse is the response struct for api UpdateEndpointGroupAttribute

func CreateUpdateEndpointGroupAttributeResponse 

func CreateUpdateEndpointGroupAttributeResponse() (response *UpdateEndpointGroupAttributeResponse)

CreateUpdateEndpointGroupAttributeResponse creates a response to parse from UpdateEndpointGroupAttribute response

type UpdateEndpointGroupEndpointConfigurations 

type UpdateEndpointGroupEndpointConfigurations struct {
	Endpoint                   string `name:"Endpoint"`
	Type                       string `name:"Type"`
	Weight                     string `name:"Weight"`
	EnableClientIPPreservation string `name:"EnableClientIPPreservation"`
	EnableProxyProtocol        string `name:"EnableProxyProtocol"`
}

UpdateEndpointGroupEndpointConfigurations is a repeated param struct in UpdateEndpointGroupRequest

type UpdateEndpointGroupRequest 

type UpdateEndpointGroupRequest struct {
	*requests.RpcRequest
	ClientToken                string                                       `position:"Query" name:"ClientToken"`
	HealthCheckIntervalSeconds requests.Integer                             `position:"Query" name:"HealthCheckIntervalSeconds"`
	Description                string                                       `position:"Query" name:"Description"`
	HealthCheckProtocol        string                                       `position:"Query" name:"HealthCheckProtocol"`
	HealthCheckPath            string                                       `position:"Query" name:"HealthCheckPath"`
	EndpointConfigurations     *[]UpdateEndpointGroupEndpointConfigurations `position:"Query" name:"EndpointConfigurations"  type:"Repeated"`
	EndpointGroupId            string                                       `position:"Query" name:"EndpointGroupId"`
	TrafficPercentage          requests.Integer                             `position:"Query" name:"TrafficPercentage"`
	HealthCheckPort            requests.Integer                             `position:"Query" name:"HealthCheckPort"`
	ThresholdCount             requests.Integer                             `position:"Query" name:"ThresholdCount"`
	EndpointGroupRegion        string                                       `position:"Query" name:"EndpointGroupRegion"`
	Name                       string                                       `position:"Query" name:"Name"`
}

UpdateEndpointGroupRequest is the request struct for api UpdateEndpointGroup

func CreateUpdateEndpointGroupRequest 

func CreateUpdateEndpointGroupRequest() (request *UpdateEndpointGroupRequest)

CreateUpdateEndpointGroupRequest creates a request to invoke UpdateEndpointGroup API

type UpdateEndpointGroupResponse 

type UpdateEndpointGroupResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateEndpointGroupResponse is the response struct for api UpdateEndpointGroup

func CreateUpdateEndpointGroupResponse 

func CreateUpdateEndpointGroupResponse() (response *UpdateEndpointGroupResponse)

CreateUpdateEndpointGroupResponse creates a response to parse from UpdateEndpointGroup response

type UpdateIpSetRequest 

type UpdateIpSetRequest struct {
	*requests.RpcRequest
	ClientToken string           `position:"Query" name:"ClientToken"`
	Bandwidth   requests.Integer `position:"Query" name:"Bandwidth"`
	IpSetId     string           `position:"Query" name:"IpSetId"`
}

UpdateIpSetRequest is the request struct for api UpdateIpSet

func CreateUpdateIpSetRequest 

func CreateUpdateIpSetRequest() (request *UpdateIpSetRequest)

CreateUpdateIpSetRequest creates a request to invoke UpdateIpSet API

type UpdateIpSetResponse 

type UpdateIpSetResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateIpSetResponse is the response struct for api UpdateIpSet

func CreateUpdateIpSetResponse 

func CreateUpdateIpSetResponse() (response *UpdateIpSetResponse)

CreateUpdateIpSetResponse creates a response to parse from UpdateIpSet response

type UpdateIpSetsIpSets 

type UpdateIpSetsIpSets struct {
	Bandwidth string `name:"Bandwidth"`
	IpSetId   string `name:"IpSetId"`
}

UpdateIpSetsIpSets is a repeated param struct in UpdateIpSetsRequest

type UpdateIpSetsRequest 

type UpdateIpSetsRequest struct {
	*requests.RpcRequest
	IpSets *[]UpdateIpSetsIpSets `position:"Query" name:"IpSets"  type:"Repeated"`
}

UpdateIpSetsRequest is the request struct for api UpdateIpSets

func CreateUpdateIpSetsRequest 

func CreateUpdateIpSetsRequest() (request *UpdateIpSetsRequest)

CreateUpdateIpSetsRequest creates a request to invoke UpdateIpSets API

type UpdateIpSetsResponse 

type UpdateIpSetsResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateIpSetsResponse is the response struct for api UpdateIpSets

func CreateUpdateIpSetsResponse 

func CreateUpdateIpSetsResponse() (response *UpdateIpSetsResponse)

CreateUpdateIpSetsResponse creates a response to parse from UpdateIpSets response

type UpdateListenerBackendPorts 

type UpdateListenerBackendPorts struct {
	FromPort string `name:"FromPort"`
	ToPort   string `name:"ToPort"`
}

UpdateListenerBackendPorts is a repeated param struct in UpdateListenerRequest

type UpdateListenerJson 

type UpdateListenerJson struct {
	Id string `name:"Id"`
}

UpdateListenerJson is a repeated param struct in UpdateListenerRequest

type UpdateListenerPortRanges 

type UpdateListenerPortRanges struct {
	FromPort string `name:"FromPort"`
	ToPort   string `name:"ToPort"`
}

UpdateListenerPortRanges is a repeated param struct in UpdateListenerRequest

type UpdateListenerRequest 

type UpdateListenerRequest struct {
	*requests.RpcRequest
	ClientToken    string                        `position:"Query" name:"ClientToken"`
	Description    string                        `position:"Query" name:"Description"`
	BackendPorts   *[]UpdateListenerBackendPorts `position:"Query" name:"BackendPorts"  type:"Repeated"`
	ListenerId     string                        `position:"Query" name:"ListenerId"`
	Protocol       string                        `position:"Query" name:"Protocol"`
	PortRanges     *[]UpdateListenerPortRanges   `position:"Query" name:"PortRanges"  type:"Repeated"`
	ProxyProtocol  string                        `position:"Query" name:"ProxyProtocol"`
	Certificates   *[]UpdateListenerJson         `position:"Query" name:"Certificates"  type:"Repeated"`
	Name           string                        `position:"Query" name:"Name"`
	ClientAffinity string                        `position:"Query" name:"ClientAffinity"`
}

UpdateListenerRequest is the request struct for api UpdateListener

func CreateUpdateListenerRequest 

func CreateUpdateListenerRequest() (request *UpdateListenerRequest)

CreateUpdateListenerRequest creates a request to invoke UpdateListener API

type UpdateListenerResponse 

type UpdateListenerResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
}

UpdateListenerResponse is the response struct for api UpdateListener

func CreateUpdateListenerResponse 

func CreateUpdateListenerResponse() (response *UpdateListenerResponse)

CreateUpdateListenerResponse creates a response to parse from UpdateListener response

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.