nlb

Documentation

Index

• Variables
• func GetEndpointMap() map[string]string
• func GetEndpointType() string
• func SetClientProperty(client *Client, propertyName string, propertyValue interface{})
• func SetEndpointDataToClient(client *Client)
• type AbnormalServer
• type AddServersToServerGroupRequest
  • func CreateAddServersToServerGroupRequest() (request *AddServersToServerGroupRequest)
• type AddServersToServerGroupResponse
  • func CreateAddServersToServerGroupResponse() (response *AddServersToServerGroupResponse)
• type AddServersToServerGroupServers
• type AttachCommonBandwidthPackageToLoadBalancerRequest
  • func CreateAttachCommonBandwidthPackageToLoadBalancerRequest() (request *AttachCommonBandwidthPackageToLoadBalancerRequest)
• type AttachCommonBandwidthPackageToLoadBalancerResponse
  • func CreateAttachCommonBandwidthPackageToLoadBalancerResponse() (response *AttachCommonBandwidthPackageToLoadBalancerResponse)
• type CaCertificateIdsInGetListenerAttribute
• type CaCertificateIdsInListListeners
• type CertificateIdsInGetListenerAttribute
• type CertificateIdsInListListenerCertificates
• type CertificateIdsInListListeners
• type Client
  • func NewClient() (client *Client, err error)
  • func NewClientWithAccessKey(regionId, accessKeyId, accessKeySecret string) (client *Client, err error)
  • func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error)
  • func NewClientWithOptions(regionId string, config *sdk.Config, credential auth.Credential) (client *Client, err error)
  • func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error)
  • func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error)
  • func NewClientWithRamRoleArnAndPolicy(regionId string, ...) (client *Client, err error)
  • func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, sessionExpiration int) (client *Client, err error)
  • func NewClientWithStsToken(regionId, stsAccessKeyId, stsAccessKeySecret, stsToken string) (client *Client, err error)
  • func (client *Client) AddServersToServerGroup(request *AddServersToServerGroupRequest) (response *AddServersToServerGroupResponse, err error)
  • func (client *Client) AddServersToServerGroupWithCallback(request *AddServersToServerGroupRequest, ...) <-chan int
  • func (client *Client) AddServersToServerGroupWithChan(request *AddServersToServerGroupRequest) (<-chan *AddServersToServerGroupResponse, <-chan error)
  • func (client *Client) AttachCommonBandwidthPackageToLoadBalancer(request *AttachCommonBandwidthPackageToLoadBalancerRequest) (response *AttachCommonBandwidthPackageToLoadBalancerResponse, err error)
  • func (client *Client) AttachCommonBandwidthPackageToLoadBalancerWithCallback(request *AttachCommonBandwidthPackageToLoadBalancerRequest, ...) <-chan int
  • func (client *Client) AttachCommonBandwidthPackageToLoadBalancerWithChan(request *AttachCommonBandwidthPackageToLoadBalancerRequest) (<-chan *AttachCommonBandwidthPackageToLoadBalancerResponse, <-chan error)
  • func (client *Client) CreateListener(request *CreateListenerRequest) (response *CreateListenerResponse, err error)
  • func (client *Client) CreateListenerWithCallback(request *CreateListenerRequest, ...) <-chan int
  • func (client *Client) CreateListenerWithChan(request *CreateListenerRequest) (<-chan *CreateListenerResponse, <-chan error)
  • func (client *Client) CreateLoadBalancer(request *CreateLoadBalancerRequest) (response *CreateLoadBalancerResponse, err error)
  • func (client *Client) CreateLoadBalancerWithCallback(request *CreateLoadBalancerRequest, ...) <-chan int
  • func (client *Client) CreateLoadBalancerWithChan(request *CreateLoadBalancerRequest) (<-chan *CreateLoadBalancerResponse, <-chan error)
  • func (client *Client) CreateSecurityPolicy(request *CreateSecurityPolicyRequest) (response *CreateSecurityPolicyResponse, err error)
  • func (client *Client) CreateSecurityPolicyWithCallback(request *CreateSecurityPolicyRequest, ...) <-chan int
  • func (client *Client) CreateSecurityPolicyWithChan(request *CreateSecurityPolicyRequest) (<-chan *CreateSecurityPolicyResponse, <-chan error)
  • func (client *Client) CreateServerGroup(request *CreateServerGroupRequest) (response *CreateServerGroupResponse, err error)
  • func (client *Client) CreateServerGroupWithCallback(request *CreateServerGroupRequest, ...) <-chan int
  • func (client *Client) CreateServerGroupWithChan(request *CreateServerGroupRequest) (<-chan *CreateServerGroupResponse, <-chan error)
  • func (client *Client) DeleteListener(request *DeleteListenerRequest) (response *DeleteListenerResponse, err error)
  • func (client *Client) DeleteListenerWithCallback(request *DeleteListenerRequest, ...) <-chan int
  • func (client *Client) DeleteListenerWithChan(request *DeleteListenerRequest) (<-chan *DeleteListenerResponse, <-chan error)
  • func (client *Client) DeleteLoadBalancer(request *DeleteLoadBalancerRequest) (response *DeleteLoadBalancerResponse, err error)
  • func (client *Client) DeleteLoadBalancerWithCallback(request *DeleteLoadBalancerRequest, ...) <-chan int
  • func (client *Client) DeleteLoadBalancerWithChan(request *DeleteLoadBalancerRequest) (<-chan *DeleteLoadBalancerResponse, <-chan error)
  • func (client *Client) DeleteSecurityPolicy(request *DeleteSecurityPolicyRequest) (response *DeleteSecurityPolicyResponse, err error)
  • func (client *Client) DeleteSecurityPolicyWithCallback(request *DeleteSecurityPolicyRequest, ...) <-chan int
  • func (client *Client) DeleteSecurityPolicyWithChan(request *DeleteSecurityPolicyRequest) (<-chan *DeleteSecurityPolicyResponse, <-chan error)
  • func (client *Client) DeleteServerGroup(request *DeleteServerGroupRequest) (response *DeleteServerGroupResponse, err error)
  • func (client *Client) DeleteServerGroupWithCallback(request *DeleteServerGroupRequest, ...) <-chan int
  • func (client *Client) DeleteServerGroupWithChan(request *DeleteServerGroupRequest) (<-chan *DeleteServerGroupResponse, <-chan error)
  • func (client *Client) DescribeRegions(request *DescribeRegionsRequest) (response *DescribeRegionsResponse, err error)
  • func (client *Client) DescribeRegionsWithCallback(request *DescribeRegionsRequest, ...) <-chan int
  • func (client *Client) DescribeRegionsWithChan(request *DescribeRegionsRequest) (<-chan *DescribeRegionsResponse, <-chan error)
  • func (client *Client) DescribeZones(request *DescribeZonesRequest) (response *DescribeZonesResponse, err error)
  • func (client *Client) DescribeZonesWithCallback(request *DescribeZonesRequest, ...) <-chan int
  • func (client *Client) DescribeZonesWithChan(request *DescribeZonesRequest) (<-chan *DescribeZonesResponse, <-chan error)
  • func (client *Client) DetachCommonBandwidthPackageFromLoadBalancer(request *DetachCommonBandwidthPackageFromLoadBalancerRequest) (response *DetachCommonBandwidthPackageFromLoadBalancerResponse, err error)
  • func (client *Client) DetachCommonBandwidthPackageFromLoadBalancerWithCallback(request *DetachCommonBandwidthPackageFromLoadBalancerRequest, ...) <-chan int
  • func (client *Client) DetachCommonBandwidthPackageFromLoadBalancerWithChan(request *DetachCommonBandwidthPackageFromLoadBalancerRequest) (<-chan *DetachCommonBandwidthPackageFromLoadBalancerResponse, <-chan error)
  • func (client *Client) DisableLoadBalancerIpv6Internet(request *DisableLoadBalancerIpv6InternetRequest) (response *DisableLoadBalancerIpv6InternetResponse, err error)
  • func (client *Client) DisableLoadBalancerIpv6InternetWithCallback(request *DisableLoadBalancerIpv6InternetRequest, ...) <-chan int
  • func (client *Client) DisableLoadBalancerIpv6InternetWithChan(request *DisableLoadBalancerIpv6InternetRequest) (<-chan *DisableLoadBalancerIpv6InternetResponse, <-chan error)
  • func (client *Client) EnableLoadBalancerIpv6Internet(request *EnableLoadBalancerIpv6InternetRequest) (response *EnableLoadBalancerIpv6InternetResponse, err error)
  • func (client *Client) EnableLoadBalancerIpv6InternetWithCallback(request *EnableLoadBalancerIpv6InternetRequest, ...) <-chan int
  • func (client *Client) EnableLoadBalancerIpv6InternetWithChan(request *EnableLoadBalancerIpv6InternetRequest) (<-chan *EnableLoadBalancerIpv6InternetResponse, <-chan error)
  • func (client *Client) GetJobStatus(request *GetJobStatusRequest) (response *GetJobStatusResponse, err error)
  • func (client *Client) GetJobStatusWithCallback(request *GetJobStatusRequest, ...) <-chan int
  • func (client *Client) GetJobStatusWithChan(request *GetJobStatusRequest) (<-chan *GetJobStatusResponse, <-chan error)
  • func (client *Client) GetListenerAttribute(request *GetListenerAttributeRequest) (response *GetListenerAttributeResponse, err error)
  • func (client *Client) GetListenerAttributeWithCallback(request *GetListenerAttributeRequest, ...) <-chan int
  • func (client *Client) GetListenerAttributeWithChan(request *GetListenerAttributeRequest) (<-chan *GetListenerAttributeResponse, <-chan error)
  • func (client *Client) GetListenerHealthStatus(request *GetListenerHealthStatusRequest) (response *GetListenerHealthStatusResponse, err error)
  • func (client *Client) GetListenerHealthStatusWithCallback(request *GetListenerHealthStatusRequest, ...) <-chan int
  • func (client *Client) GetListenerHealthStatusWithChan(request *GetListenerHealthStatusRequest) (<-chan *GetListenerHealthStatusResponse, <-chan error)
  • func (client *Client) GetLoadBalancerAttribute(request *GetLoadBalancerAttributeRequest) (response *GetLoadBalancerAttributeResponse, err error)
  • func (client *Client) GetLoadBalancerAttributeWithCallback(request *GetLoadBalancerAttributeRequest, ...) <-chan int
  • func (client *Client) GetLoadBalancerAttributeWithChan(request *GetLoadBalancerAttributeRequest) (<-chan *GetLoadBalancerAttributeResponse, <-chan error)
  • func (client *Client) ListListenerCertificates(request *ListListenerCertificatesRequest) (response *ListListenerCertificatesResponse, err error)
  • func (client *Client) ListListenerCertificatesWithCallback(request *ListListenerCertificatesRequest, ...) <-chan int
  • func (client *Client) ListListenerCertificatesWithChan(request *ListListenerCertificatesRequest) (<-chan *ListListenerCertificatesResponse, <-chan error)
  • func (client *Client) ListListeners(request *ListListenersRequest) (response *ListListenersResponse, err error)
  • func (client *Client) ListListenersWithCallback(request *ListListenersRequest, ...) <-chan int
  • func (client *Client) ListListenersWithChan(request *ListListenersRequest) (<-chan *ListListenersResponse, <-chan error)
  • func (client *Client) ListLoadBalancers(request *ListLoadBalancersRequest) (response *ListLoadBalancersResponse, err error)
  • func (client *Client) ListLoadBalancersWithCallback(request *ListLoadBalancersRequest, ...) <-chan int
  • func (client *Client) ListLoadBalancersWithChan(request *ListLoadBalancersRequest) (<-chan *ListLoadBalancersResponse, <-chan error)
  • func (client *Client) ListSecurityPolicy(request *ListSecurityPolicyRequest) (response *ListSecurityPolicyResponse, err error)
  • func (client *Client) ListSecurityPolicyWithCallback(request *ListSecurityPolicyRequest, ...) <-chan int
  • func (client *Client) ListSecurityPolicyWithChan(request *ListSecurityPolicyRequest) (<-chan *ListSecurityPolicyResponse, <-chan error)
  • func (client *Client) ListServerGroupServers(request *ListServerGroupServersRequest) (response *ListServerGroupServersResponse, err error)
  • func (client *Client) ListServerGroupServersWithCallback(request *ListServerGroupServersRequest, ...) <-chan int
  • func (client *Client) ListServerGroupServersWithChan(request *ListServerGroupServersRequest) (<-chan *ListServerGroupServersResponse, <-chan error)
  • func (client *Client) ListServerGroups(request *ListServerGroupsRequest) (response *ListServerGroupsResponse, err error)
  • func (client *Client) ListServerGroupsWithCallback(request *ListServerGroupsRequest, ...) <-chan int
  • func (client *Client) ListServerGroupsWithChan(request *ListServerGroupsRequest) (<-chan *ListServerGroupsResponse, <-chan error)
  • func (client *Client) ListSystemSecurityPolicy(request *ListSystemSecurityPolicyRequest) (response *ListSystemSecurityPolicyResponse, err error)
  • func (client *Client) ListSystemSecurityPolicyWithCallback(request *ListSystemSecurityPolicyRequest, ...) <-chan int
  • func (client *Client) ListSystemSecurityPolicyWithChan(request *ListSystemSecurityPolicyRequest) (<-chan *ListSystemSecurityPolicyResponse, <-chan error)
  • func (client *Client) ListTagResources(request *ListTagResourcesRequest) (response *ListTagResourcesResponse, err error)
  • func (client *Client) ListTagResourcesWithCallback(request *ListTagResourcesRequest, ...) <-chan int
  • func (client *Client) ListTagResourcesWithChan(request *ListTagResourcesRequest) (<-chan *ListTagResourcesResponse, <-chan error)
  • func (client *Client) LoadBalancerJoinSecurityGroup(request *LoadBalancerJoinSecurityGroupRequest) (response *LoadBalancerJoinSecurityGroupResponse, err error)
  • func (client *Client) LoadBalancerJoinSecurityGroupWithCallback(request *LoadBalancerJoinSecurityGroupRequest, ...) <-chan int
  • func (client *Client) LoadBalancerJoinSecurityGroupWithChan(request *LoadBalancerJoinSecurityGroupRequest) (<-chan *LoadBalancerJoinSecurityGroupResponse, <-chan error)
  • func (client *Client) LoadBalancerLeaveSecurityGroup(request *LoadBalancerLeaveSecurityGroupRequest) (response *LoadBalancerLeaveSecurityGroupResponse, err error)
  • func (client *Client) LoadBalancerLeaveSecurityGroupWithCallback(request *LoadBalancerLeaveSecurityGroupRequest, ...) <-chan int
  • func (client *Client) LoadBalancerLeaveSecurityGroupWithChan(request *LoadBalancerLeaveSecurityGroupRequest) (<-chan *LoadBalancerLeaveSecurityGroupResponse, <-chan error)
  • func (client *Client) RemoveServersFromServerGroup(request *RemoveServersFromServerGroupRequest) (response *RemoveServersFromServerGroupResponse, err error)
  • func (client *Client) RemoveServersFromServerGroupWithCallback(request *RemoveServersFromServerGroupRequest, ...) <-chan int
  • func (client *Client) RemoveServersFromServerGroupWithChan(request *RemoveServersFromServerGroupRequest) (<-chan *RemoveServersFromServerGroupResponse, <-chan error)
  • func (client *Client) StartListener(request *StartListenerRequest) (response *StartListenerResponse, err error)
  • func (client *Client) StartListenerWithCallback(request *StartListenerRequest, ...) <-chan int
  • func (client *Client) StartListenerWithChan(request *StartListenerRequest) (<-chan *StartListenerResponse, <-chan error)
  • func (client *Client) StopListener(request *StopListenerRequest) (response *StopListenerResponse, err error)
  • func (client *Client) StopListenerWithCallback(request *StopListenerRequest, ...) <-chan int
  • func (client *Client) StopListenerWithChan(request *StopListenerRequest) (<-chan *StopListenerResponse, <-chan error)
  • func (client *Client) TagResources(request *TagResourcesRequest) (response *TagResourcesResponse, err error)
  • func (client *Client) TagResourcesWithCallback(request *TagResourcesRequest, ...) <-chan int
  • func (client *Client) TagResourcesWithChan(request *TagResourcesRequest) (<-chan *TagResourcesResponse, <-chan error)
  • func (client *Client) UntagResources(request *UntagResourcesRequest) (response *UntagResourcesResponse, err error)
  • func (client *Client) UntagResourcesWithCallback(request *UntagResourcesRequest, ...) <-chan int
  • func (client *Client) UntagResourcesWithChan(request *UntagResourcesRequest) (<-chan *UntagResourcesResponse, <-chan error)
  • func (client *Client) UpdateListenerAttribute(request *UpdateListenerAttributeRequest) (response *UpdateListenerAttributeResponse, err error)
  • func (client *Client) UpdateListenerAttributeWithCallback(request *UpdateListenerAttributeRequest, ...) <-chan int
  • func (client *Client) UpdateListenerAttributeWithChan(request *UpdateListenerAttributeRequest) (<-chan *UpdateListenerAttributeResponse, <-chan error)
  • func (client *Client) UpdateLoadBalancerAddressTypeConfig(request *UpdateLoadBalancerAddressTypeConfigRequest) (response *UpdateLoadBalancerAddressTypeConfigResponse, err error)
  • func (client *Client) UpdateLoadBalancerAddressTypeConfigWithCallback(request *UpdateLoadBalancerAddressTypeConfigRequest, ...) <-chan int
  • func (client *Client) UpdateLoadBalancerAddressTypeConfigWithChan(request *UpdateLoadBalancerAddressTypeConfigRequest) (<-chan *UpdateLoadBalancerAddressTypeConfigResponse, <-chan error)
  • func (client *Client) UpdateLoadBalancerAttribute(request *UpdateLoadBalancerAttributeRequest) (response *UpdateLoadBalancerAttributeResponse, err error)
  • func (client *Client) UpdateLoadBalancerAttributeWithCallback(request *UpdateLoadBalancerAttributeRequest, ...) <-chan int
  • func (client *Client) UpdateLoadBalancerAttributeWithChan(request *UpdateLoadBalancerAttributeRequest) (<-chan *UpdateLoadBalancerAttributeResponse, <-chan error)
  • func (client *Client) UpdateLoadBalancerProtection(request *UpdateLoadBalancerProtectionRequest) (response *UpdateLoadBalancerProtectionResponse, err error)
  • func (client *Client) UpdateLoadBalancerProtectionWithCallback(request *UpdateLoadBalancerProtectionRequest, ...) <-chan int
  • func (client *Client) UpdateLoadBalancerProtectionWithChan(request *UpdateLoadBalancerProtectionRequest) (<-chan *UpdateLoadBalancerProtectionResponse, <-chan error)
  • func (client *Client) UpdateLoadBalancerZones(request *UpdateLoadBalancerZonesRequest) (response *UpdateLoadBalancerZonesResponse, err error)
  • func (client *Client) UpdateLoadBalancerZonesWithCallback(request *UpdateLoadBalancerZonesRequest, ...) <-chan int
  • func (client *Client) UpdateLoadBalancerZonesWithChan(request *UpdateLoadBalancerZonesRequest) (<-chan *UpdateLoadBalancerZonesResponse, <-chan error)
  • func (client *Client) UpdateSecurityPolicyAttribute(request *UpdateSecurityPolicyAttributeRequest) (response *UpdateSecurityPolicyAttributeResponse, err error)
  • func (client *Client) UpdateSecurityPolicyAttributeWithCallback(request *UpdateSecurityPolicyAttributeRequest, ...) <-chan int
  • func (client *Client) UpdateSecurityPolicyAttributeWithChan(request *UpdateSecurityPolicyAttributeRequest) (<-chan *UpdateSecurityPolicyAttributeResponse, <-chan error)
  • func (client *Client) UpdateServerGroupAttribute(request *UpdateServerGroupAttributeRequest) (response *UpdateServerGroupAttributeResponse, err error)
  • func (client *Client) UpdateServerGroupAttributeWithCallback(request *UpdateServerGroupAttributeRequest, ...) <-chan int
  • func (client *Client) UpdateServerGroupAttributeWithChan(request *UpdateServerGroupAttributeRequest) (<-chan *UpdateServerGroupAttributeResponse, <-chan error)
  • func (client *Client) UpdateServerGroupServersAttribute(request *UpdateServerGroupServersAttributeRequest) (response *UpdateServerGroupServersAttributeResponse, err error)
  • func (client *Client) UpdateServerGroupServersAttributeWithCallback(request *UpdateServerGroupServersAttributeRequest, ...) <-chan int
  • func (client *Client) UpdateServerGroupServersAttributeWithChan(request *UpdateServerGroupServersAttributeRequest) (<-chan *UpdateServerGroupServersAttributeResponse, <-chan error)
• type CreateListenerRequest
  • func CreateCreateListenerRequest() (request *CreateListenerRequest)
• type CreateListenerResponse
  • func CreateCreateListenerResponse() (response *CreateListenerResponse)
• type CreateLoadBalancerDeletionProtectionConfig
• type CreateLoadBalancerLoadBalancerBillingConfig
• type CreateLoadBalancerModificationProtectionConfig
• type CreateLoadBalancerRequest
  • func CreateCreateLoadBalancerRequest() (request *CreateLoadBalancerRequest)
• type CreateLoadBalancerResponse
  • func CreateCreateLoadBalancerResponse() (response *CreateLoadBalancerResponse)
• type CreateLoadBalancerZoneMappings
• type CreateSecurityPolicyRequest
  • func CreateCreateSecurityPolicyRequest() (request *CreateSecurityPolicyRequest)
• type CreateSecurityPolicyResponse
  • func CreateCreateSecurityPolicyResponse() (response *CreateSecurityPolicyResponse)
• type CreateServerGroupHealthCheckConfig
• type CreateServerGroupRequest
  • func CreateCreateServerGroupRequest() (request *CreateServerGroupRequest)
• type CreateServerGroupResponse
  • func CreateCreateServerGroupResponse() (response *CreateServerGroupResponse)
• type DeleteListenerRequest
  • func CreateDeleteListenerRequest() (request *DeleteListenerRequest)
• type DeleteListenerResponse
  • func CreateDeleteListenerResponse() (response *DeleteListenerResponse)
• type DeleteLoadBalancerRequest
  • func CreateDeleteLoadBalancerRequest() (request *DeleteLoadBalancerRequest)
• type DeleteLoadBalancerResponse
  • func CreateDeleteLoadBalancerResponse() (response *DeleteLoadBalancerResponse)
• type DeleteSecurityPolicyRequest
  • func CreateDeleteSecurityPolicyRequest() (request *DeleteSecurityPolicyRequest)
• type DeleteSecurityPolicyResponse
  • func CreateDeleteSecurityPolicyResponse() (response *DeleteSecurityPolicyResponse)
• type DeleteServerGroupRequest
  • func CreateDeleteServerGroupRequest() (request *DeleteServerGroupRequest)
• type DeleteServerGroupResponse
  • func CreateDeleteServerGroupResponse() (response *DeleteServerGroupResponse)
• type DeletionProtectionConfig
• type DescribeRegionsRequest
  • func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)
• type DescribeRegionsResponse
  • func CreateDescribeRegionsResponse() (response *DescribeRegionsResponse)
• type DescribeZonesRequest
  • func CreateDescribeZonesRequest() (request *DescribeZonesRequest)
• type DescribeZonesResponse
  • func CreateDescribeZonesResponse() (response *DescribeZonesResponse)
• type DetachCommonBandwidthPackageFromLoadBalancerRequest
  • func CreateDetachCommonBandwidthPackageFromLoadBalancerRequest() (request *DetachCommonBandwidthPackageFromLoadBalancerRequest)
• type DetachCommonBandwidthPackageFromLoadBalancerResponse
  • func CreateDetachCommonBandwidthPackageFromLoadBalancerResponse() (response *DetachCommonBandwidthPackageFromLoadBalancerResponse)
• type DisableLoadBalancerIpv6InternetRequest
  • func CreateDisableLoadBalancerIpv6InternetRequest() (request *DisableLoadBalancerIpv6InternetRequest)
• type DisableLoadBalancerIpv6InternetResponse
  • func CreateDisableLoadBalancerIpv6InternetResponse() (response *DisableLoadBalancerIpv6InternetResponse)
• type EnableLoadBalancerIpv6InternetRequest
  • func CreateEnableLoadBalancerIpv6InternetRequest() (request *EnableLoadBalancerIpv6InternetRequest)
• type EnableLoadBalancerIpv6InternetResponse
  • func CreateEnableLoadBalancerIpv6InternetResponse() (response *EnableLoadBalancerIpv6InternetResponse)
• type GetJobStatusRequest
  • func CreateGetJobStatusRequest() (request *GetJobStatusRequest)
• type GetJobStatusResponse
  • func CreateGetJobStatusResponse() (response *GetJobStatusResponse)
• type GetListenerAttributeRequest
  • func CreateGetListenerAttributeRequest() (request *GetListenerAttributeRequest)
• type GetListenerAttributeResponse
  • func CreateGetListenerAttributeResponse() (response *GetListenerAttributeResponse)
• type GetListenerHealthStatusRequest
  • func CreateGetListenerHealthStatusRequest() (request *GetListenerHealthStatusRequest)
• type GetListenerHealthStatusResponse
  • func CreateGetListenerHealthStatusResponse() (response *GetListenerHealthStatusResponse)
• type GetLoadBalancerAttributeRequest
  • func CreateGetLoadBalancerAttributeRequest() (request *GetLoadBalancerAttributeRequest)
• type GetLoadBalancerAttributeResponse
  • func CreateGetLoadBalancerAttributeResponse() (response *GetLoadBalancerAttributeResponse)
• type HealthCheck
• type HealthCheckHttpCode
• type ListListenerCertificatesRequest
  • func CreateListListenerCertificatesRequest() (request *ListListenerCertificatesRequest)
• type ListListenerCertificatesResponse
  • func CreateListListenerCertificatesResponse() (response *ListListenerCertificatesResponse)
• type ListListenersRequest
  • func CreateListListenersRequest() (request *ListListenersRequest)
• type ListListenersResponse
  • func CreateListListenersResponse() (response *ListListenersResponse)
• type ListLoadBalancersRequest
  • func CreateListLoadBalancersRequest() (request *ListLoadBalancersRequest)
• type ListLoadBalancersResponse
  • func CreateListLoadBalancersResponse() (response *ListLoadBalancersResponse)
• type ListLoadBalancersTag
• type ListSecurityPolicyRequest
  • func CreateListSecurityPolicyRequest() (request *ListSecurityPolicyRequest)
• type ListSecurityPolicyResponse
  • func CreateListSecurityPolicyResponse() (response *ListSecurityPolicyResponse)
• type ListSecurityPolicyTag
• type ListServerGroupServersRequest
  • func CreateListServerGroupServersRequest() (request *ListServerGroupServersRequest)
• type ListServerGroupServersResponse
  • func CreateListServerGroupServersResponse() (response *ListServerGroupServersResponse)
• type ListServerGroupsRequest
  • func CreateListServerGroupsRequest() (request *ListServerGroupsRequest)
• type ListServerGroupsResponse
  • func CreateListServerGroupsResponse() (response *ListServerGroupsResponse)
• type ListServerGroupsTag
• type ListSystemSecurityPolicyRequest
  • func CreateListSystemSecurityPolicyRequest() (request *ListSystemSecurityPolicyRequest)
• type ListSystemSecurityPolicyResponse
  • func CreateListSystemSecurityPolicyResponse() (response *ListSystemSecurityPolicyResponse)
• type ListTagResourcesRequest
  • func CreateListTagResourcesRequest() (request *ListTagResourcesRequest)
• type ListTagResourcesResponse
  • func CreateListTagResourcesResponse() (response *ListTagResourcesResponse)
• type ListTagResourcesTag
• type ListenerHealthStatus
• type ListenerHealthStatusItem
• type ListenerInfo
• type Listeners
• type LoadBalancerAddress
• type LoadBalancerAddressesInGetLoadBalancerAttribute
• type LoadBalancerAddressesInListLoadBalancers
• type LoadBalancerBillingConfig
• type LoadBalancerJoinSecurityGroupRequest
  • func CreateLoadBalancerJoinSecurityGroupRequest() (request *LoadBalancerJoinSecurityGroupRequest)
• type LoadBalancerJoinSecurityGroupResponse
  • func CreateLoadBalancerJoinSecurityGroupResponse() (response *LoadBalancerJoinSecurityGroupResponse)
• type LoadBalancerLeaveSecurityGroupRequest
  • func CreateLoadBalancerLeaveSecurityGroupRequest() (request *LoadBalancerLeaveSecurityGroupRequest)
• type LoadBalancerLeaveSecurityGroupResponse
  • func CreateLoadBalancerLeaveSecurityGroupResponse() (response *LoadBalancerLeaveSecurityGroupResponse)
• type LoadBalancers
• type LoadbalancerInfo
• type ModificationProtectionConfig
• type NonNormalServers
• type OperationLock
• type OperationLocksInGetLoadBalancerAttribute
• type OperationLocksInListLoadBalancers
• type Reason
• type Region
• type Regions
• type RelatedListener
• type RelatedListeners
• type RelatedLoadBalancerIds
• type RemoveServersFromServerGroupRequest
  • func CreateRemoveServersFromServerGroupRequest() (request *RemoveServersFromServerGroupRequest)
• type RemoveServersFromServerGroupResponse
  • func CreateRemoveServersFromServerGroupResponse() (response *RemoveServersFromServerGroupResponse)
• type RemoveServersFromServerGroupServers
• type SecurityGroupIdsInGetLoadBalancerAttribute
• type SecurityGroupIdsInListLoadBalancers
• type SecurityPolicie
• type SecurityPoliciesInListSecurityPolicy
• type SecurityPoliciesInListSystemSecurityPolicy
• type Server
• type ServerGroup
• type ServerGroupInfo
• type ServerGroupInfos
• type ServerGroups
• type Servers
• type StartListenerRequest
  • func CreateStartListenerRequest() (request *StartListenerRequest)
• type StartListenerResponse
  • func CreateStartListenerResponse() (response *StartListenerResponse)
• type StopListenerRequest
  • func CreateStopListenerRequest() (request *StopListenerRequest)
• type StopListenerResponse
  • func CreateStopListenerResponse() (response *StopListenerResponse)
• type Tag
• type TagModels
• type TagResources
• type TagResourcesRequest
  • func CreateTagResourcesRequest() (request *TagResourcesRequest)
• type TagResourcesResponse
  • func CreateTagResourcesResponse() (response *TagResourcesResponse)
• type TagResourcesTag
• type TagResultModelList
• type TagsInListLoadBalancers
• type TagsInListSecurityPolicy
• type TagsInListServerGroups
• type UntagResourcesRequest
  • func CreateUntagResourcesRequest() (request *UntagResourcesRequest)
• type UntagResourcesResponse
  • func CreateUntagResourcesResponse() (response *UntagResourcesResponse)
• type UpdateListenerAttributeRequest
  • func CreateUpdateListenerAttributeRequest() (request *UpdateListenerAttributeRequest)
• type UpdateListenerAttributeResponse
  • func CreateUpdateListenerAttributeResponse() (response *UpdateListenerAttributeResponse)
• type UpdateLoadBalancerAddressTypeConfigRequest
  • func CreateUpdateLoadBalancerAddressTypeConfigRequest() (request *UpdateLoadBalancerAddressTypeConfigRequest)
• type UpdateLoadBalancerAddressTypeConfigResponse
  • func CreateUpdateLoadBalancerAddressTypeConfigResponse() (response *UpdateLoadBalancerAddressTypeConfigResponse)
• type UpdateLoadBalancerAddressTypeConfigZoneMappings
• type UpdateLoadBalancerAttributeRequest
  • func CreateUpdateLoadBalancerAttributeRequest() (request *UpdateLoadBalancerAttributeRequest)
• type UpdateLoadBalancerAttributeResponse
  • func CreateUpdateLoadBalancerAttributeResponse() (response *UpdateLoadBalancerAttributeResponse)
• type UpdateLoadBalancerProtectionRequest
  • func CreateUpdateLoadBalancerProtectionRequest() (request *UpdateLoadBalancerProtectionRequest)
• type UpdateLoadBalancerProtectionResponse
  • func CreateUpdateLoadBalancerProtectionResponse() (response *UpdateLoadBalancerProtectionResponse)
• type UpdateLoadBalancerZonesRequest
  • func CreateUpdateLoadBalancerZonesRequest() (request *UpdateLoadBalancerZonesRequest)
• type UpdateLoadBalancerZonesResponse
  • func CreateUpdateLoadBalancerZonesResponse() (response *UpdateLoadBalancerZonesResponse)
• type UpdateLoadBalancerZonesZoneMappings
• type UpdateSecurityPolicyAttributeRequest
  • func CreateUpdateSecurityPolicyAttributeRequest() (request *UpdateSecurityPolicyAttributeRequest)
• type UpdateSecurityPolicyAttributeResponse
  • func CreateUpdateSecurityPolicyAttributeResponse() (response *UpdateSecurityPolicyAttributeResponse)
• type UpdateServerGroupAttributeHealthCheckConfig
• type UpdateServerGroupAttributeRequest
  • func CreateUpdateServerGroupAttributeRequest() (request *UpdateServerGroupAttributeRequest)
• type UpdateServerGroupAttributeResponse
  • func CreateUpdateServerGroupAttributeResponse() (response *UpdateServerGroupAttributeResponse)
• type UpdateServerGroupServersAttributeRequest
  • func CreateUpdateServerGroupServersAttributeRequest() (request *UpdateServerGroupServersAttributeRequest)
• type UpdateServerGroupServersAttributeResponse
  • func CreateUpdateServerGroupServersAttributeResponse() (response *UpdateServerGroupServersAttributeResponse)
• type UpdateServerGroupServersAttributeServers
• type Zone
• type ZoneMapping
• type ZoneMappingsInGetLoadBalancerAttribute
• type ZoneMappingsInListLoadBalancers
• type Zones

Variables

var EndpointMap map[string]string

EndpointMap Endpoint Data

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 AbnormalServer

type AbnormalServer struct {
	Status   string `json:"Status" xml:"Status"`
	Port     int    `json:"Port" xml:"Port"`
	ServerId string `json:"ServerId" xml:"ServerId"`
	ServerIp string `json:"ServerIp" xml:"ServerIp"`
	Reason   Reason `json:"Reason" xml:"Reason"`
}

AbnormalServer is a nested struct in nlb response

type AddServersToServerGroupRequest

type AddServersToServerGroupRequest struct {
	*requests.RpcRequest
	ClientToken   string                            `position:"Body" name:"ClientToken"`
	ServerGroupId string                            `position:"Body" name:"ServerGroupId"`
	Servers       *[]AddServersToServerGroupServers `position:"Body" name:"Servers"  type:"Repeated"`
	DryRun        requests.Boolean                  `position:"Body" name:"DryRun"`
}

AddServersToServerGroupRequest is the request struct for api AddServersToServerGroup

func CreateAddServersToServerGroupRequest

func CreateAddServersToServerGroupRequest() (request *AddServersToServerGroupRequest)

CreateAddServersToServerGroupRequest creates a request to invoke AddServersToServerGroup API

type AddServersToServerGroupResponse

type AddServersToServerGroupResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ServerGroupId  string `json:"ServerGroupId" xml:"ServerGroupId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

AddServersToServerGroupResponse is the response struct for api AddServersToServerGroup

func CreateAddServersToServerGroupResponse

func CreateAddServersToServerGroupResponse() (response *AddServersToServerGroupResponse)

CreateAddServersToServerGroupResponse creates a response to parse from AddServersToServerGroup response

type AddServersToServerGroupServers

type AddServersToServerGroupServers struct {
	ServerId    string `name:"ServerId"`
	ServerType  string `name:"ServerType"`
	ServerIp    string `name:"ServerIp"`
	Port        string `name:"Port"`
	Weight      string `name:"Weight"`
	Description string `name:"Description"`
}

AddServersToServerGroupServers is a repeated param struct in AddServersToServerGroupRequest

type AttachCommonBandwidthPackageToLoadBalancerRequest

type AttachCommonBandwidthPackageToLoadBalancerRequest struct {
	*requests.RpcRequest
	ClientToken        string           `position:"Body" name:"ClientToken"`
	BandwidthPackageId string           `position:"Body" name:"BandwidthPackageId"`
	DryRun             requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId     string           `position:"Body" name:"LoadBalancerId"`
}

AttachCommonBandwidthPackageToLoadBalancerRequest is the request struct for api AttachCommonBandwidthPackageToLoadBalancer

func CreateAttachCommonBandwidthPackageToLoadBalancerRequest

func CreateAttachCommonBandwidthPackageToLoadBalancerRequest() (request *AttachCommonBandwidthPackageToLoadBalancerRequest)

CreateAttachCommonBandwidthPackageToLoadBalancerRequest creates a request to invoke AttachCommonBandwidthPackageToLoadBalancer API

type AttachCommonBandwidthPackageToLoadBalancerResponse

type AttachCommonBandwidthPackageToLoadBalancerResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

AttachCommonBandwidthPackageToLoadBalancerResponse is the response struct for api AttachCommonBandwidthPackageToLoadBalancer

func CreateAttachCommonBandwidthPackageToLoadBalancerResponse

func CreateAttachCommonBandwidthPackageToLoadBalancerResponse() (response *AttachCommonBandwidthPackageToLoadBalancerResponse)

CreateAttachCommonBandwidthPackageToLoadBalancerResponse creates a response to parse from AttachCommonBandwidthPackageToLoadBalancer response

type CaCertificateIdsInGetListenerAttribute

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

CaCertificateIdsInGetListenerAttribute is a nested struct in nlb response

type CaCertificateIdsInListListeners

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

CaCertificateIdsInListListeners is a nested struct in nlb response

type CertificateIdsInGetListenerAttribute

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

CertificateIdsInGetListenerAttribute is a nested struct in nlb response

type CertificateIdsInListListenerCertificates

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

CertificateIdsInListListenerCertificates is a nested struct in nlb response

type CertificateIdsInListListeners

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

CertificateIdsInListListeners is a nested struct in nlb 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) AddServersToServerGroup

func (client *Client) AddServersToServerGroup(request *AddServersToServerGroupRequest) (response *AddServersToServerGroupResponse, err error)

AddServersToServerGroup invokes the nlb.AddServersToServerGroup API synchronously

func (*Client) AddServersToServerGroupWithCallback

func (client *Client) AddServersToServerGroupWithCallback(request *AddServersToServerGroupRequest, callback func(response *AddServersToServerGroupResponse, err error)) <-chan int

AddServersToServerGroupWithCallback invokes the nlb.AddServersToServerGroup API asynchronously

func (*Client) AddServersToServerGroupWithChan

func (client *Client) AddServersToServerGroupWithChan(request *AddServersToServerGroupRequest) (<-chan *AddServersToServerGroupResponse, <-chan error)

AddServersToServerGroupWithChan invokes the nlb.AddServersToServerGroup API asynchronously

func (*Client) AttachCommonBandwidthPackageToLoadBalancer

func (client *Client) AttachCommonBandwidthPackageToLoadBalancer(request *AttachCommonBandwidthPackageToLoadBalancerRequest) (response *AttachCommonBandwidthPackageToLoadBalancerResponse, err error)

AttachCommonBandwidthPackageToLoadBalancer invokes the nlb.AttachCommonBandwidthPackageToLoadBalancer API synchronously

func (*Client) AttachCommonBandwidthPackageToLoadBalancerWithCallback

func (client *Client) AttachCommonBandwidthPackageToLoadBalancerWithCallback(request *AttachCommonBandwidthPackageToLoadBalancerRequest, callback func(response *AttachCommonBandwidthPackageToLoadBalancerResponse, err error)) <-chan int

AttachCommonBandwidthPackageToLoadBalancerWithCallback invokes the nlb.AttachCommonBandwidthPackageToLoadBalancer API asynchronously

func (*Client) AttachCommonBandwidthPackageToLoadBalancerWithChan

func (client *Client) AttachCommonBandwidthPackageToLoadBalancerWithChan(request *AttachCommonBandwidthPackageToLoadBalancerRequest) (<-chan *AttachCommonBandwidthPackageToLoadBalancerResponse, <-chan error)

AttachCommonBandwidthPackageToLoadBalancerWithChan invokes the nlb.AttachCommonBandwidthPackageToLoadBalancer API asynchronously

func (*Client) CreateListener

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

CreateListener invokes the nlb.CreateListener API synchronously

func (*Client) CreateListenerWithCallback

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

CreateListenerWithCallback invokes the nlb.CreateListener API asynchronously

func (*Client) CreateListenerWithChan

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

CreateListenerWithChan invokes the nlb.CreateListener API asynchronously

func (*Client) CreateLoadBalancer

func (client *Client) CreateLoadBalancer(request *CreateLoadBalancerRequest) (response *CreateLoadBalancerResponse, err error)

CreateLoadBalancer invokes the nlb.CreateLoadBalancer API synchronously

func (*Client) CreateLoadBalancerWithCallback

func (client *Client) CreateLoadBalancerWithCallback(request *CreateLoadBalancerRequest, callback func(response *CreateLoadBalancerResponse, err error)) <-chan int

CreateLoadBalancerWithCallback invokes the nlb.CreateLoadBalancer API asynchronously

func (*Client) CreateLoadBalancerWithChan

func (client *Client) CreateLoadBalancerWithChan(request *CreateLoadBalancerRequest) (<-chan *CreateLoadBalancerResponse, <-chan error)

CreateLoadBalancerWithChan invokes the nlb.CreateLoadBalancer API asynchronously

func (*Client) CreateSecurityPolicy

func (client *Client) CreateSecurityPolicy(request *CreateSecurityPolicyRequest) (response *CreateSecurityPolicyResponse, err error)

CreateSecurityPolicy invokes the nlb.CreateSecurityPolicy API synchronously

func (*Client) CreateSecurityPolicyWithCallback

func (client *Client) CreateSecurityPolicyWithCallback(request *CreateSecurityPolicyRequest, callback func(response *CreateSecurityPolicyResponse, err error)) <-chan int

CreateSecurityPolicyWithCallback invokes the nlb.CreateSecurityPolicy API asynchronously

func (*Client) CreateSecurityPolicyWithChan

func (client *Client) CreateSecurityPolicyWithChan(request *CreateSecurityPolicyRequest) (<-chan *CreateSecurityPolicyResponse, <-chan error)

CreateSecurityPolicyWithChan invokes the nlb.CreateSecurityPolicy API asynchronously

func (*Client) CreateServerGroup

func (client *Client) CreateServerGroup(request *CreateServerGroupRequest) (response *CreateServerGroupResponse, err error)

CreateServerGroup invokes the nlb.CreateServerGroup API synchronously

func (*Client) CreateServerGroupWithCallback

func (client *Client) CreateServerGroupWithCallback(request *CreateServerGroupRequest, callback func(response *CreateServerGroupResponse, err error)) <-chan int

CreateServerGroupWithCallback invokes the nlb.CreateServerGroup API asynchronously

func (*Client) CreateServerGroupWithChan

func (client *Client) CreateServerGroupWithChan(request *CreateServerGroupRequest) (<-chan *CreateServerGroupResponse, <-chan error)

CreateServerGroupWithChan invokes the nlb.CreateServerGroup API asynchronously

func (*Client) DeleteListener

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

DeleteListener invokes the nlb.DeleteListener API synchronously

func (*Client) DeleteListenerWithCallback

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

DeleteListenerWithCallback invokes the nlb.DeleteListener API asynchronously

func (*Client) DeleteListenerWithChan

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

DeleteListenerWithChan invokes the nlb.DeleteListener API asynchronously

func (*Client) DeleteLoadBalancer

func (client *Client) DeleteLoadBalancer(request *DeleteLoadBalancerRequest) (response *DeleteLoadBalancerResponse, err error)

DeleteLoadBalancer invokes the nlb.DeleteLoadBalancer API synchronously

func (*Client) DeleteLoadBalancerWithCallback

func (client *Client) DeleteLoadBalancerWithCallback(request *DeleteLoadBalancerRequest, callback func(response *DeleteLoadBalancerResponse, err error)) <-chan int

DeleteLoadBalancerWithCallback invokes the nlb.DeleteLoadBalancer API asynchronously

func (*Client) DeleteLoadBalancerWithChan

func (client *Client) DeleteLoadBalancerWithChan(request *DeleteLoadBalancerRequest) (<-chan *DeleteLoadBalancerResponse, <-chan error)

DeleteLoadBalancerWithChan invokes the nlb.DeleteLoadBalancer API asynchronously

func (*Client) DeleteSecurityPolicy

func (client *Client) DeleteSecurityPolicy(request *DeleteSecurityPolicyRequest) (response *DeleteSecurityPolicyResponse, err error)

DeleteSecurityPolicy invokes the nlb.DeleteSecurityPolicy API synchronously

func (*Client) DeleteSecurityPolicyWithCallback

func (client *Client) DeleteSecurityPolicyWithCallback(request *DeleteSecurityPolicyRequest, callback func(response *DeleteSecurityPolicyResponse, err error)) <-chan int

DeleteSecurityPolicyWithCallback invokes the nlb.DeleteSecurityPolicy API asynchronously

func (*Client) DeleteSecurityPolicyWithChan

func (client *Client) DeleteSecurityPolicyWithChan(request *DeleteSecurityPolicyRequest) (<-chan *DeleteSecurityPolicyResponse, <-chan error)

DeleteSecurityPolicyWithChan invokes the nlb.DeleteSecurityPolicy API asynchronously

func (*Client) DeleteServerGroup

func (client *Client) DeleteServerGroup(request *DeleteServerGroupRequest) (response *DeleteServerGroupResponse, err error)

DeleteServerGroup invokes the nlb.DeleteServerGroup API synchronously

func (*Client) DeleteServerGroupWithCallback

func (client *Client) DeleteServerGroupWithCallback(request *DeleteServerGroupRequest, callback func(response *DeleteServerGroupResponse, err error)) <-chan int

DeleteServerGroupWithCallback invokes the nlb.DeleteServerGroup API asynchronously

func (*Client) DeleteServerGroupWithChan

func (client *Client) DeleteServerGroupWithChan(request *DeleteServerGroupRequest) (<-chan *DeleteServerGroupResponse, <-chan error)

DeleteServerGroupWithChan invokes the nlb.DeleteServerGroup API asynchronously

func (*Client) DescribeRegions

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

DescribeRegions invokes the nlb.DescribeRegions API synchronously

func (*Client) DescribeRegionsWithCallback

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

DescribeRegionsWithCallback invokes the nlb.DescribeRegions API asynchronously

func (*Client) DescribeRegionsWithChan

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

DescribeRegionsWithChan invokes the nlb.DescribeRegions API asynchronously

func (*Client) DescribeZones

func (client *Client) DescribeZones(request *DescribeZonesRequest) (response *DescribeZonesResponse, err error)

DescribeZones invokes the nlb.DescribeZones API synchronously

func (*Client) DescribeZonesWithCallback

func (client *Client) DescribeZonesWithCallback(request *DescribeZonesRequest, callback func(response *DescribeZonesResponse, err error)) <-chan int

DescribeZonesWithCallback invokes the nlb.DescribeZones API asynchronously

func (*Client) DescribeZonesWithChan

func (client *Client) DescribeZonesWithChan(request *DescribeZonesRequest) (<-chan *DescribeZonesResponse, <-chan error)

DescribeZonesWithChan invokes the nlb.DescribeZones API asynchronously

func (*Client) DetachCommonBandwidthPackageFromLoadBalancer

func (client *Client) DetachCommonBandwidthPackageFromLoadBalancer(request *DetachCommonBandwidthPackageFromLoadBalancerRequest) (response *DetachCommonBandwidthPackageFromLoadBalancerResponse, err error)

DetachCommonBandwidthPackageFromLoadBalancer invokes the nlb.DetachCommonBandwidthPackageFromLoadBalancer API synchronously

func (*Client) DetachCommonBandwidthPackageFromLoadBalancerWithCallback

func (client *Client) DetachCommonBandwidthPackageFromLoadBalancerWithCallback(request *DetachCommonBandwidthPackageFromLoadBalancerRequest, callback func(response *DetachCommonBandwidthPackageFromLoadBalancerResponse, err error)) <-chan int

DetachCommonBandwidthPackageFromLoadBalancerWithCallback invokes the nlb.DetachCommonBandwidthPackageFromLoadBalancer API asynchronously

func (*Client) DetachCommonBandwidthPackageFromLoadBalancerWithChan

func (client *Client) DetachCommonBandwidthPackageFromLoadBalancerWithChan(request *DetachCommonBandwidthPackageFromLoadBalancerRequest) (<-chan *DetachCommonBandwidthPackageFromLoadBalancerResponse, <-chan error)

DetachCommonBandwidthPackageFromLoadBalancerWithChan invokes the nlb.DetachCommonBandwidthPackageFromLoadBalancer API asynchronously

func (*Client) DisableLoadBalancerIpv6Internet

func (client *Client) DisableLoadBalancerIpv6Internet(request *DisableLoadBalancerIpv6InternetRequest) (response *DisableLoadBalancerIpv6InternetResponse, err error)

DisableLoadBalancerIpv6Internet invokes the nlb.DisableLoadBalancerIpv6Internet API synchronously

func (*Client) DisableLoadBalancerIpv6InternetWithCallback

func (client *Client) DisableLoadBalancerIpv6InternetWithCallback(request *DisableLoadBalancerIpv6InternetRequest, callback func(response *DisableLoadBalancerIpv6InternetResponse, err error)) <-chan int

DisableLoadBalancerIpv6InternetWithCallback invokes the nlb.DisableLoadBalancerIpv6Internet API asynchronously

func (*Client) DisableLoadBalancerIpv6InternetWithChan

func (client *Client) DisableLoadBalancerIpv6InternetWithChan(request *DisableLoadBalancerIpv6InternetRequest) (<-chan *DisableLoadBalancerIpv6InternetResponse, <-chan error)

DisableLoadBalancerIpv6InternetWithChan invokes the nlb.DisableLoadBalancerIpv6Internet API asynchronously

func (*Client) EnableLoadBalancerIpv6Internet

func (client *Client) EnableLoadBalancerIpv6Internet(request *EnableLoadBalancerIpv6InternetRequest) (response *EnableLoadBalancerIpv6InternetResponse, err error)

EnableLoadBalancerIpv6Internet invokes the nlb.EnableLoadBalancerIpv6Internet API synchronously

func (*Client) EnableLoadBalancerIpv6InternetWithCallback

func (client *Client) EnableLoadBalancerIpv6InternetWithCallback(request *EnableLoadBalancerIpv6InternetRequest, callback func(response *EnableLoadBalancerIpv6InternetResponse, err error)) <-chan int

EnableLoadBalancerIpv6InternetWithCallback invokes the nlb.EnableLoadBalancerIpv6Internet API asynchronously

func (*Client) EnableLoadBalancerIpv6InternetWithChan

func (client *Client) EnableLoadBalancerIpv6InternetWithChan(request *EnableLoadBalancerIpv6InternetRequest) (<-chan *EnableLoadBalancerIpv6InternetResponse, <-chan error)

EnableLoadBalancerIpv6InternetWithChan invokes the nlb.EnableLoadBalancerIpv6Internet API asynchronously

func (*Client) GetJobStatus

func (client *Client) GetJobStatus(request *GetJobStatusRequest) (response *GetJobStatusResponse, err error)

GetJobStatus invokes the nlb.GetJobStatus API synchronously

func (*Client) GetJobStatusWithCallback

func (client *Client) GetJobStatusWithCallback(request *GetJobStatusRequest, callback func(response *GetJobStatusResponse, err error)) <-chan int

GetJobStatusWithCallback invokes the nlb.GetJobStatus API asynchronously

func (*Client) GetJobStatusWithChan

func (client *Client) GetJobStatusWithChan(request *GetJobStatusRequest) (<-chan *GetJobStatusResponse, <-chan error)

GetJobStatusWithChan invokes the nlb.GetJobStatus API asynchronously

func (*Client) GetListenerAttribute

func (client *Client) GetListenerAttribute(request *GetListenerAttributeRequest) (response *GetListenerAttributeResponse, err error)

GetListenerAttribute invokes the nlb.GetListenerAttribute API synchronously

func (*Client) GetListenerAttributeWithCallback

func (client *Client) GetListenerAttributeWithCallback(request *GetListenerAttributeRequest, callback func(response *GetListenerAttributeResponse, err error)) <-chan int

GetListenerAttributeWithCallback invokes the nlb.GetListenerAttribute API asynchronously

func (*Client) GetListenerAttributeWithChan

func (client *Client) GetListenerAttributeWithChan(request *GetListenerAttributeRequest) (<-chan *GetListenerAttributeResponse, <-chan error)

GetListenerAttributeWithChan invokes the nlb.GetListenerAttribute API asynchronously

func (*Client) GetListenerHealthStatus

func (client *Client) GetListenerHealthStatus(request *GetListenerHealthStatusRequest) (response *GetListenerHealthStatusResponse, err error)

GetListenerHealthStatus invokes the nlb.GetListenerHealthStatus API synchronously

func (*Client) GetListenerHealthStatusWithCallback

func (client *Client) GetListenerHealthStatusWithCallback(request *GetListenerHealthStatusRequest, callback func(response *GetListenerHealthStatusResponse, err error)) <-chan int

GetListenerHealthStatusWithCallback invokes the nlb.GetListenerHealthStatus API asynchronously

func (*Client) GetListenerHealthStatusWithChan

func (client *Client) GetListenerHealthStatusWithChan(request *GetListenerHealthStatusRequest) (<-chan *GetListenerHealthStatusResponse, <-chan error)

GetListenerHealthStatusWithChan invokes the nlb.GetListenerHealthStatus API asynchronously

func (*Client) GetLoadBalancerAttribute

func (client *Client) GetLoadBalancerAttribute(request *GetLoadBalancerAttributeRequest) (response *GetLoadBalancerAttributeResponse, err error)

GetLoadBalancerAttribute invokes the nlb.GetLoadBalancerAttribute API synchronously

func (*Client) GetLoadBalancerAttributeWithCallback

func (client *Client) GetLoadBalancerAttributeWithCallback(request *GetLoadBalancerAttributeRequest, callback func(response *GetLoadBalancerAttributeResponse, err error)) <-chan int

GetLoadBalancerAttributeWithCallback invokes the nlb.GetLoadBalancerAttribute API asynchronously

func (*Client) GetLoadBalancerAttributeWithChan

func (client *Client) GetLoadBalancerAttributeWithChan(request *GetLoadBalancerAttributeRequest) (<-chan *GetLoadBalancerAttributeResponse, <-chan error)

GetLoadBalancerAttributeWithChan invokes the nlb.GetLoadBalancerAttribute API asynchronously

func (*Client) ListListenerCertificates

func (client *Client) ListListenerCertificates(request *ListListenerCertificatesRequest) (response *ListListenerCertificatesResponse, err error)

ListListenerCertificates invokes the nlb.ListListenerCertificates API synchronously

func (*Client) ListListenerCertificatesWithCallback

func (client *Client) ListListenerCertificatesWithCallback(request *ListListenerCertificatesRequest, callback func(response *ListListenerCertificatesResponse, err error)) <-chan int

ListListenerCertificatesWithCallback invokes the nlb.ListListenerCertificates API asynchronously

func (*Client) ListListenerCertificatesWithChan

func (client *Client) ListListenerCertificatesWithChan(request *ListListenerCertificatesRequest) (<-chan *ListListenerCertificatesResponse, <-chan error)

ListListenerCertificatesWithChan invokes the nlb.ListListenerCertificates API asynchronously

func (*Client) ListListeners

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

ListListeners invokes the nlb.ListListeners API synchronously

func (*Client) ListListenersWithCallback

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

ListListenersWithCallback invokes the nlb.ListListeners API asynchronously

func (*Client) ListListenersWithChan

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

ListListenersWithChan invokes the nlb.ListListeners API asynchronously

func (*Client) ListLoadBalancers

func (client *Client) ListLoadBalancers(request *ListLoadBalancersRequest) (response *ListLoadBalancersResponse, err error)

ListLoadBalancers invokes the nlb.ListLoadBalancers API synchronously

func (*Client) ListLoadBalancersWithCallback

func (client *Client) ListLoadBalancersWithCallback(request *ListLoadBalancersRequest, callback func(response *ListLoadBalancersResponse, err error)) <-chan int

ListLoadBalancersWithCallback invokes the nlb.ListLoadBalancers API asynchronously

func (*Client) ListLoadBalancersWithChan

func (client *Client) ListLoadBalancersWithChan(request *ListLoadBalancersRequest) (<-chan *ListLoadBalancersResponse, <-chan error)

ListLoadBalancersWithChan invokes the nlb.ListLoadBalancers API asynchronously

func (*Client) ListSecurityPolicy

func (client *Client) ListSecurityPolicy(request *ListSecurityPolicyRequest) (response *ListSecurityPolicyResponse, err error)

ListSecurityPolicy invokes the nlb.ListSecurityPolicy API synchronously

func (*Client) ListSecurityPolicyWithCallback

func (client *Client) ListSecurityPolicyWithCallback(request *ListSecurityPolicyRequest, callback func(response *ListSecurityPolicyResponse, err error)) <-chan int

ListSecurityPolicyWithCallback invokes the nlb.ListSecurityPolicy API asynchronously

func (*Client) ListSecurityPolicyWithChan

func (client *Client) ListSecurityPolicyWithChan(request *ListSecurityPolicyRequest) (<-chan *ListSecurityPolicyResponse, <-chan error)

ListSecurityPolicyWithChan invokes the nlb.ListSecurityPolicy API asynchronously

func (*Client) ListServerGroupServers

func (client *Client) ListServerGroupServers(request *ListServerGroupServersRequest) (response *ListServerGroupServersResponse, err error)

ListServerGroupServers invokes the nlb.ListServerGroupServers API synchronously

func (*Client) ListServerGroupServersWithCallback

func (client *Client) ListServerGroupServersWithCallback(request *ListServerGroupServersRequest, callback func(response *ListServerGroupServersResponse, err error)) <-chan int

ListServerGroupServersWithCallback invokes the nlb.ListServerGroupServers API asynchronously

func (*Client) ListServerGroupServersWithChan

func (client *Client) ListServerGroupServersWithChan(request *ListServerGroupServersRequest) (<-chan *ListServerGroupServersResponse, <-chan error)

ListServerGroupServersWithChan invokes the nlb.ListServerGroupServers API asynchronously

func (*Client) ListServerGroups

func (client *Client) ListServerGroups(request *ListServerGroupsRequest) (response *ListServerGroupsResponse, err error)

ListServerGroups invokes the nlb.ListServerGroups API synchronously

func (*Client) ListServerGroupsWithCallback

func (client *Client) ListServerGroupsWithCallback(request *ListServerGroupsRequest, callback func(response *ListServerGroupsResponse, err error)) <-chan int

ListServerGroupsWithCallback invokes the nlb.ListServerGroups API asynchronously

func (*Client) ListServerGroupsWithChan

func (client *Client) ListServerGroupsWithChan(request *ListServerGroupsRequest) (<-chan *ListServerGroupsResponse, <-chan error)

ListServerGroupsWithChan invokes the nlb.ListServerGroups API asynchronously

func (*Client) ListSystemSecurityPolicy

func (client *Client) ListSystemSecurityPolicy(request *ListSystemSecurityPolicyRequest) (response *ListSystemSecurityPolicyResponse, err error)

ListSystemSecurityPolicy invokes the nlb.ListSystemSecurityPolicy API synchronously

func (*Client) ListSystemSecurityPolicyWithCallback

func (client *Client) ListSystemSecurityPolicyWithCallback(request *ListSystemSecurityPolicyRequest, callback func(response *ListSystemSecurityPolicyResponse, err error)) <-chan int

ListSystemSecurityPolicyWithCallback invokes the nlb.ListSystemSecurityPolicy API asynchronously

func (*Client) ListSystemSecurityPolicyWithChan

func (client *Client) ListSystemSecurityPolicyWithChan(request *ListSystemSecurityPolicyRequest) (<-chan *ListSystemSecurityPolicyResponse, <-chan error)

ListSystemSecurityPolicyWithChan invokes the nlb.ListSystemSecurityPolicy API asynchronously

func (*Client) ListTagResources

func (client *Client) ListTagResources(request *ListTagResourcesRequest) (response *ListTagResourcesResponse, err error)

ListTagResources invokes the nlb.ListTagResources API synchronously

func (*Client) ListTagResourcesWithCallback

func (client *Client) ListTagResourcesWithCallback(request *ListTagResourcesRequest, callback func(response *ListTagResourcesResponse, err error)) <-chan int

ListTagResourcesWithCallback invokes the nlb.ListTagResources API asynchronously

func (*Client) ListTagResourcesWithChan

func (client *Client) ListTagResourcesWithChan(request *ListTagResourcesRequest) (<-chan *ListTagResourcesResponse, <-chan error)

ListTagResourcesWithChan invokes the nlb.ListTagResources API asynchronously

func (*Client) LoadBalancerJoinSecurityGroup

func (client *Client) LoadBalancerJoinSecurityGroup(request *LoadBalancerJoinSecurityGroupRequest) (response *LoadBalancerJoinSecurityGroupResponse, err error)

LoadBalancerJoinSecurityGroup invokes the nlb.LoadBalancerJoinSecurityGroup API synchronously

func (*Client) LoadBalancerJoinSecurityGroupWithCallback

func (client *Client) LoadBalancerJoinSecurityGroupWithCallback(request *LoadBalancerJoinSecurityGroupRequest, callback func(response *LoadBalancerJoinSecurityGroupResponse, err error)) <-chan int

LoadBalancerJoinSecurityGroupWithCallback invokes the nlb.LoadBalancerJoinSecurityGroup API asynchronously

func (*Client) LoadBalancerJoinSecurityGroupWithChan

func (client *Client) LoadBalancerJoinSecurityGroupWithChan(request *LoadBalancerJoinSecurityGroupRequest) (<-chan *LoadBalancerJoinSecurityGroupResponse, <-chan error)

LoadBalancerJoinSecurityGroupWithChan invokes the nlb.LoadBalancerJoinSecurityGroup API asynchronously

func (*Client) LoadBalancerLeaveSecurityGroup

func (client *Client) LoadBalancerLeaveSecurityGroup(request *LoadBalancerLeaveSecurityGroupRequest) (response *LoadBalancerLeaveSecurityGroupResponse, err error)

LoadBalancerLeaveSecurityGroup invokes the nlb.LoadBalancerLeaveSecurityGroup API synchronously

func (*Client) LoadBalancerLeaveSecurityGroupWithCallback

func (client *Client) LoadBalancerLeaveSecurityGroupWithCallback(request *LoadBalancerLeaveSecurityGroupRequest, callback func(response *LoadBalancerLeaveSecurityGroupResponse, err error)) <-chan int

LoadBalancerLeaveSecurityGroupWithCallback invokes the nlb.LoadBalancerLeaveSecurityGroup API asynchronously

func (*Client) LoadBalancerLeaveSecurityGroupWithChan

func (client *Client) LoadBalancerLeaveSecurityGroupWithChan(request *LoadBalancerLeaveSecurityGroupRequest) (<-chan *LoadBalancerLeaveSecurityGroupResponse, <-chan error)

LoadBalancerLeaveSecurityGroupWithChan invokes the nlb.LoadBalancerLeaveSecurityGroup API asynchronously

func (*Client) RemoveServersFromServerGroup

func (client *Client) RemoveServersFromServerGroup(request *RemoveServersFromServerGroupRequest) (response *RemoveServersFromServerGroupResponse, err error)

RemoveServersFromServerGroup invokes the nlb.RemoveServersFromServerGroup API synchronously

func (*Client) RemoveServersFromServerGroupWithCallback

func (client *Client) RemoveServersFromServerGroupWithCallback(request *RemoveServersFromServerGroupRequest, callback func(response *RemoveServersFromServerGroupResponse, err error)) <-chan int

RemoveServersFromServerGroupWithCallback invokes the nlb.RemoveServersFromServerGroup API asynchronously

func (*Client) RemoveServersFromServerGroupWithChan

func (client *Client) RemoveServersFromServerGroupWithChan(request *RemoveServersFromServerGroupRequest) (<-chan *RemoveServersFromServerGroupResponse, <-chan error)

RemoveServersFromServerGroupWithChan invokes the nlb.RemoveServersFromServerGroup API asynchronously

func (*Client) StartListener

func (client *Client) StartListener(request *StartListenerRequest) (response *StartListenerResponse, err error)

StartListener invokes the nlb.StartListener API synchronously

func (*Client) StartListenerWithCallback

func (client *Client) StartListenerWithCallback(request *StartListenerRequest, callback func(response *StartListenerResponse, err error)) <-chan int

StartListenerWithCallback invokes the nlb.StartListener API asynchronously

func (*Client) StartListenerWithChan

func (client *Client) StartListenerWithChan(request *StartListenerRequest) (<-chan *StartListenerResponse, <-chan error)

StartListenerWithChan invokes the nlb.StartListener API asynchronously

func (*Client) StopListener

func (client *Client) StopListener(request *StopListenerRequest) (response *StopListenerResponse, err error)

StopListener invokes the nlb.StopListener API synchronously

func (*Client) StopListenerWithCallback

func (client *Client) StopListenerWithCallback(request *StopListenerRequest, callback func(response *StopListenerResponse, err error)) <-chan int

StopListenerWithCallback invokes the nlb.StopListener API asynchronously

func (*Client) StopListenerWithChan

func (client *Client) StopListenerWithChan(request *StopListenerRequest) (<-chan *StopListenerResponse, <-chan error)

StopListenerWithChan invokes the nlb.StopListener API asynchronously

func (*Client) TagResources

func (client *Client) TagResources(request *TagResourcesRequest) (response *TagResourcesResponse, err error)

TagResources invokes the nlb.TagResources API synchronously

func (*Client) TagResourcesWithCallback

func (client *Client) TagResourcesWithCallback(request *TagResourcesRequest, callback func(response *TagResourcesResponse, err error)) <-chan int

TagResourcesWithCallback invokes the nlb.TagResources API asynchronously

func (*Client) TagResourcesWithChan

func (client *Client) TagResourcesWithChan(request *TagResourcesRequest) (<-chan *TagResourcesResponse, <-chan error)

TagResourcesWithChan invokes the nlb.TagResources API asynchronously

func (*Client) UntagResources

func (client *Client) UntagResources(request *UntagResourcesRequest) (response *UntagResourcesResponse, err error)

UntagResources invokes the nlb.UntagResources API synchronously

func (*Client) UntagResourcesWithCallback

func (client *Client) UntagResourcesWithCallback(request *UntagResourcesRequest, callback func(response *UntagResourcesResponse, err error)) <-chan int

UntagResourcesWithCallback invokes the nlb.UntagResources API asynchronously

func (*Client) UntagResourcesWithChan

func (client *Client) UntagResourcesWithChan(request *UntagResourcesRequest) (<-chan *UntagResourcesResponse, <-chan error)

UntagResourcesWithChan invokes the nlb.UntagResources API asynchronously

func (*Client) UpdateListenerAttribute

func (client *Client) UpdateListenerAttribute(request *UpdateListenerAttributeRequest) (response *UpdateListenerAttributeResponse, err error)

UpdateListenerAttribute invokes the nlb.UpdateListenerAttribute API synchronously

func (*Client) UpdateListenerAttributeWithCallback

func (client *Client) UpdateListenerAttributeWithCallback(request *UpdateListenerAttributeRequest, callback func(response *UpdateListenerAttributeResponse, err error)) <-chan int

UpdateListenerAttributeWithCallback invokes the nlb.UpdateListenerAttribute API asynchronously

func (*Client) UpdateListenerAttributeWithChan

func (client *Client) UpdateListenerAttributeWithChan(request *UpdateListenerAttributeRequest) (<-chan *UpdateListenerAttributeResponse, <-chan error)

UpdateListenerAttributeWithChan invokes the nlb.UpdateListenerAttribute API asynchronously

func (*Client) UpdateLoadBalancerAddressTypeConfig

func (client *Client) UpdateLoadBalancerAddressTypeConfig(request *UpdateLoadBalancerAddressTypeConfigRequest) (response *UpdateLoadBalancerAddressTypeConfigResponse, err error)

UpdateLoadBalancerAddressTypeConfig invokes the nlb.UpdateLoadBalancerAddressTypeConfig API synchronously

func (*Client) UpdateLoadBalancerAddressTypeConfigWithCallback

func (client *Client) UpdateLoadBalancerAddressTypeConfigWithCallback(request *UpdateLoadBalancerAddressTypeConfigRequest, callback func(response *UpdateLoadBalancerAddressTypeConfigResponse, err error)) <-chan int

UpdateLoadBalancerAddressTypeConfigWithCallback invokes the nlb.UpdateLoadBalancerAddressTypeConfig API asynchronously

func (*Client) UpdateLoadBalancerAddressTypeConfigWithChan

func (client *Client) UpdateLoadBalancerAddressTypeConfigWithChan(request *UpdateLoadBalancerAddressTypeConfigRequest) (<-chan *UpdateLoadBalancerAddressTypeConfigResponse, <-chan error)

UpdateLoadBalancerAddressTypeConfigWithChan invokes the nlb.UpdateLoadBalancerAddressTypeConfig API asynchronously

func (*Client) UpdateLoadBalancerAttribute

func (client *Client) UpdateLoadBalancerAttribute(request *UpdateLoadBalancerAttributeRequest) (response *UpdateLoadBalancerAttributeResponse, err error)

UpdateLoadBalancerAttribute invokes the nlb.UpdateLoadBalancerAttribute API synchronously

func (*Client) UpdateLoadBalancerAttributeWithCallback

func (client *Client) UpdateLoadBalancerAttributeWithCallback(request *UpdateLoadBalancerAttributeRequest, callback func(response *UpdateLoadBalancerAttributeResponse, err error)) <-chan int

UpdateLoadBalancerAttributeWithCallback invokes the nlb.UpdateLoadBalancerAttribute API asynchronously

func (*Client) UpdateLoadBalancerAttributeWithChan

func (client *Client) UpdateLoadBalancerAttributeWithChan(request *UpdateLoadBalancerAttributeRequest) (<-chan *UpdateLoadBalancerAttributeResponse, <-chan error)

UpdateLoadBalancerAttributeWithChan invokes the nlb.UpdateLoadBalancerAttribute API asynchronously

func (*Client) UpdateLoadBalancerProtection

func (client *Client) UpdateLoadBalancerProtection(request *UpdateLoadBalancerProtectionRequest) (response *UpdateLoadBalancerProtectionResponse, err error)

UpdateLoadBalancerProtection invokes the nlb.UpdateLoadBalancerProtection API synchronously

func (*Client) UpdateLoadBalancerProtectionWithCallback

func (client *Client) UpdateLoadBalancerProtectionWithCallback(request *UpdateLoadBalancerProtectionRequest, callback func(response *UpdateLoadBalancerProtectionResponse, err error)) <-chan int

UpdateLoadBalancerProtectionWithCallback invokes the nlb.UpdateLoadBalancerProtection API asynchronously

func (*Client) UpdateLoadBalancerProtectionWithChan

func (client *Client) UpdateLoadBalancerProtectionWithChan(request *UpdateLoadBalancerProtectionRequest) (<-chan *UpdateLoadBalancerProtectionResponse, <-chan error)

UpdateLoadBalancerProtectionWithChan invokes the nlb.UpdateLoadBalancerProtection API asynchronously

func (*Client) UpdateLoadBalancerZones

func (client *Client) UpdateLoadBalancerZones(request *UpdateLoadBalancerZonesRequest) (response *UpdateLoadBalancerZonesResponse, err error)

UpdateLoadBalancerZones invokes the nlb.UpdateLoadBalancerZones API synchronously

func (*Client) UpdateLoadBalancerZonesWithCallback

func (client *Client) UpdateLoadBalancerZonesWithCallback(request *UpdateLoadBalancerZonesRequest, callback func(response *UpdateLoadBalancerZonesResponse, err error)) <-chan int

UpdateLoadBalancerZonesWithCallback invokes the nlb.UpdateLoadBalancerZones API asynchronously

func (*Client) UpdateLoadBalancerZonesWithChan

func (client *Client) UpdateLoadBalancerZonesWithChan(request *UpdateLoadBalancerZonesRequest) (<-chan *UpdateLoadBalancerZonesResponse, <-chan error)

UpdateLoadBalancerZonesWithChan invokes the nlb.UpdateLoadBalancerZones API asynchronously

func (*Client) UpdateSecurityPolicyAttribute

func (client *Client) UpdateSecurityPolicyAttribute(request *UpdateSecurityPolicyAttributeRequest) (response *UpdateSecurityPolicyAttributeResponse, err error)

UpdateSecurityPolicyAttribute invokes the nlb.UpdateSecurityPolicyAttribute API synchronously

func (*Client) UpdateSecurityPolicyAttributeWithCallback

func (client *Client) UpdateSecurityPolicyAttributeWithCallback(request *UpdateSecurityPolicyAttributeRequest, callback func(response *UpdateSecurityPolicyAttributeResponse, err error)) <-chan int

UpdateSecurityPolicyAttributeWithCallback invokes the nlb.UpdateSecurityPolicyAttribute API asynchronously

func (*Client) UpdateSecurityPolicyAttributeWithChan

func (client *Client) UpdateSecurityPolicyAttributeWithChan(request *UpdateSecurityPolicyAttributeRequest) (<-chan *UpdateSecurityPolicyAttributeResponse, <-chan error)

UpdateSecurityPolicyAttributeWithChan invokes the nlb.UpdateSecurityPolicyAttribute API asynchronously

func (*Client) UpdateServerGroupAttribute

func (client *Client) UpdateServerGroupAttribute(request *UpdateServerGroupAttributeRequest) (response *UpdateServerGroupAttributeResponse, err error)

UpdateServerGroupAttribute invokes the nlb.UpdateServerGroupAttribute API synchronously

func (*Client) UpdateServerGroupAttributeWithCallback

func (client *Client) UpdateServerGroupAttributeWithCallback(request *UpdateServerGroupAttributeRequest, callback func(response *UpdateServerGroupAttributeResponse, err error)) <-chan int

UpdateServerGroupAttributeWithCallback invokes the nlb.UpdateServerGroupAttribute API asynchronously

func (*Client) UpdateServerGroupAttributeWithChan

func (client *Client) UpdateServerGroupAttributeWithChan(request *UpdateServerGroupAttributeRequest) (<-chan *UpdateServerGroupAttributeResponse, <-chan error)

UpdateServerGroupAttributeWithChan invokes the nlb.UpdateServerGroupAttribute API asynchronously

func (*Client) UpdateServerGroupServersAttribute

func (client *Client) UpdateServerGroupServersAttribute(request *UpdateServerGroupServersAttributeRequest) (response *UpdateServerGroupServersAttributeResponse, err error)

UpdateServerGroupServersAttribute invokes the nlb.UpdateServerGroupServersAttribute API synchronously

func (*Client) UpdateServerGroupServersAttributeWithCallback

func (client *Client) UpdateServerGroupServersAttributeWithCallback(request *UpdateServerGroupServersAttributeRequest, callback func(response *UpdateServerGroupServersAttributeResponse, err error)) <-chan int

UpdateServerGroupServersAttributeWithCallback invokes the nlb.UpdateServerGroupServersAttribute API asynchronously

func (*Client) UpdateServerGroupServersAttributeWithChan

func (client *Client) UpdateServerGroupServersAttributeWithChan(request *UpdateServerGroupServersAttributeRequest) (<-chan *UpdateServerGroupServersAttributeResponse, <-chan error)

UpdateServerGroupServersAttributeWithChan invokes the nlb.UpdateServerGroupServersAttribute API asynchronously

type CreateListenerRequest

type CreateListenerRequest struct {
	*requests.RpcRequest
	CaCertificateIds     *[]string        `position:"Body" name:"CaCertificateIds"  type:"Repeated"`
	StartPort            requests.Integer `position:"Body" name:"StartPort"`
	ClientToken          string           `position:"Body" name:"ClientToken"`
	SecSensorEnabled     requests.Boolean `position:"Body" name:"SecSensorEnabled"`
	AlpnPolicy           string           `position:"Body" name:"AlpnPolicy"`
	Mss                  requests.Integer `position:"Body" name:"Mss"`
	ServerGroupId        string           `position:"Body" name:"ServerGroupId"`
	CertificateIds       *[]string        `position:"Body" name:"CertificateIds"  type:"Repeated"`
	AlpnEnabled          requests.Boolean `position:"Body" name:"AlpnEnabled"`
	EndPort              requests.Integer `position:"Body" name:"EndPort"`
	ListenerPort         requests.Integer `position:"Body" name:"ListenerPort"`
	DryRun               requests.Boolean `position:"Body" name:"DryRun"`
	ProxyProtocolEnabled requests.Boolean `position:"Body" name:"ProxyProtocolEnabled"`
	Cps                  requests.Integer `position:"Body" name:"Cps"`
	ListenerProtocol     string           `position:"Body" name:"ListenerProtocol"`
	SecurityPolicyId     string           `position:"Body" name:"SecurityPolicyId"`
	IdleTimeout          requests.Integer `position:"Body" name:"IdleTimeout"`
	LoadBalancerId       string           `position:"Body" name:"LoadBalancerId"`
	ListenerDescription  string           `position:"Body" name:"ListenerDescription"`
	CaEnabled            requests.Boolean `position:"Body" name:"CaEnabled"`
}

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
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ListenerId     string `json:"ListenerId" xml:"ListenerId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

CreateListenerResponse is the response struct for api CreateListener

func CreateCreateListenerResponse

func CreateCreateListenerResponse() (response *CreateListenerResponse)

CreateCreateListenerResponse creates a response to parse from CreateListener response

type CreateLoadBalancerDeletionProtectionConfig

type CreateLoadBalancerDeletionProtectionConfig struct {
	Enabled string `name:"Enabled"`
	Reason  string `name:"Reason"`
}

CreateLoadBalancerDeletionProtectionConfig is a repeated param struct in CreateLoadBalancerRequest

type CreateLoadBalancerLoadBalancerBillingConfig

type CreateLoadBalancerLoadBalancerBillingConfig struct {
	PayType string `name:"PayType"`
}

CreateLoadBalancerLoadBalancerBillingConfig is a repeated param struct in CreateLoadBalancerRequest

type CreateLoadBalancerModificationProtectionConfig

type CreateLoadBalancerModificationProtectionConfig struct {
	Status string `name:"Status"`
	Reason string `name:"Reason"`
}

CreateLoadBalancerModificationProtectionConfig is a repeated param struct in CreateLoadBalancerRequest

type CreateLoadBalancerRequest

type CreateLoadBalancerRequest struct {
	*requests.RpcRequest
	ClientToken                  string                                         `position:"Body" name:"ClientToken"`
	ModificationProtectionConfig CreateLoadBalancerModificationProtectionConfig `position:"Body" name:"ModificationProtectionConfig"  type:"Struct"`
	LoadBalancerBillingConfig    CreateLoadBalancerLoadBalancerBillingConfig    `position:"Body" name:"LoadBalancerBillingConfig"  type:"Struct"`
	BizFlag                      string                                         `position:"Body" name:"BizFlag"`
	DeletionProtectionConfig     CreateLoadBalancerDeletionProtectionConfig     `position:"Body" name:"DeletionProtectionConfig"  type:"Struct"`
	AddressIpVersion             string                                         `position:"Body" name:"AddressIpVersion"`
	ResourceGroupId              string                                         `position:"Body" name:"ResourceGroupId"`
	LoadBalancerName             string                                         `position:"Body" name:"LoadBalancerName"`
	AddressType                  string                                         `position:"Body" name:"AddressType"`
	BandwidthPackageId           string                                         `position:"Body" name:"BandwidthPackageId"`
	DryRun                       requests.Boolean                               `position:"Body" name:"DryRun"`
	ZoneMappings                 *[]CreateLoadBalancerZoneMappings              `position:"Body" name:"ZoneMappings"  type:"Repeated"`
	SecurityGroupIds             *[]string                                      `position:"Body" name:"SecurityGroupIds"  type:"Repeated"`
	LoadBalancerType             string                                         `position:"Body" name:"LoadBalancerType"`
	VpcId                        string                                         `position:"Body" name:"VpcId"`
}

CreateLoadBalancerRequest is the request struct for api CreateLoadBalancer

func CreateCreateLoadBalancerRequest

func CreateCreateLoadBalancerRequest() (request *CreateLoadBalancerRequest)

CreateCreateLoadBalancerRequest creates a request to invoke CreateLoadBalancer API

type CreateLoadBalancerResponse

type CreateLoadBalancerResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	LoadbalancerId string `json:"LoadbalancerId" xml:"LoadbalancerId"`
	JobId          string `json:"JobId" xml:"JobId"`
	OrderId        int64  `json:"OrderId" xml:"OrderId"`
}

CreateLoadBalancerResponse is the response struct for api CreateLoadBalancer

func CreateCreateLoadBalancerResponse

func CreateCreateLoadBalancerResponse() (response *CreateLoadBalancerResponse)

CreateCreateLoadBalancerResponse creates a response to parse from CreateLoadBalancer response

type CreateLoadBalancerZoneMappings

type CreateLoadBalancerZoneMappings struct {
	VSwitchId          string `name:"VSwitchId"`
	ZoneId             string `name:"ZoneId"`
	PrivateIPv4Address string `name:"PrivateIPv4Address"`
	AllocationId       string `name:"AllocationId"`
}

CreateLoadBalancerZoneMappings is a repeated param struct in CreateLoadBalancerRequest

type CreateSecurityPolicyRequest

type CreateSecurityPolicyRequest struct {
	*requests.RpcRequest
	ClientToken        string           `position:"Body" name:"ClientToken"`
	ResourceGroupId    string           `position:"Body" name:"ResourceGroupId"`
	Ciphers            *[]string        `position:"Body" name:"Ciphers"  type:"Repeated"`
	TlsVersions        *[]string        `position:"Body" name:"TlsVersions"  type:"Repeated"`
	SecurityPolicyName string           `position:"Body" name:"SecurityPolicyName"`
	DryRun             requests.Boolean `position:"Body" name:"DryRun"`
}

CreateSecurityPolicyRequest is the request struct for api CreateSecurityPolicy

func CreateCreateSecurityPolicyRequest

func CreateCreateSecurityPolicyRequest() (request *CreateSecurityPolicyRequest)

CreateCreateSecurityPolicyRequest creates a request to invoke CreateSecurityPolicy API

type CreateSecurityPolicyResponse

type CreateSecurityPolicyResponse struct {
	*responses.BaseResponse
	RequestId        string `json:"RequestId" xml:"RequestId"`
	Success          bool   `json:"Success" xml:"Success"`
	Code             string `json:"Code" xml:"Code"`
	Message          string `json:"Message" xml:"Message"`
	HttpStatusCode   int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode      string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage   string `json:"DynamicMessage" xml:"DynamicMessage"`
	SecurityPolicyId string `json:"SecurityPolicyId" xml:"SecurityPolicyId"`
	JobId            string `json:"JobId" xml:"JobId"`
}

CreateSecurityPolicyResponse is the response struct for api CreateSecurityPolicy

func CreateCreateSecurityPolicyResponse

func CreateCreateSecurityPolicyResponse() (response *CreateSecurityPolicyResponse)

CreateCreateSecurityPolicyResponse creates a response to parse from CreateSecurityPolicy response

type CreateServerGroupHealthCheckConfig

type CreateServerGroupHealthCheckConfig struct {
	HealthCheckEnabled        string    `name:"HealthCheckEnabled"`
	HealthCheckType           string    `name:"HealthCheckType"`
	HealthCheckConnectPort    string    `name:"HealthCheckConnectPort"`
	HealthyThreshold          string    `name:"HealthyThreshold"`
	UnhealthyThreshold        string    `name:"UnhealthyThreshold"`
	HealthCheckConnectTimeout string    `name:"HealthCheckConnectTimeout"`
	HealthCheckInterval       string    `name:"HealthCheckInterval"`
	HealthCheckDomain         string    `name:"HealthCheckDomain"`
	HealthCheckUrl            string    `name:"HealthCheckUrl"`
	HealthCheckHttpCode       *[]string `name:"HealthCheckHttpCode" type:"Repeated"`
	HttpCheckMethod           string    `name:"HttpCheckMethod"`
}

CreateServerGroupHealthCheckConfig is a repeated param struct in CreateServerGroupRequest

type CreateServerGroupRequest

type CreateServerGroupRequest struct {
	*requests.RpcRequest
	ServerGroupName         string                             `position:"Body" name:"ServerGroupName"`
	ClientToken             string                             `position:"Body" name:"ClientToken"`
	PreserveClientIpEnabled requests.Boolean                   `position:"Body" name:"PreserveClientIpEnabled"`
	HealthCheckConfig       CreateServerGroupHealthCheckConfig `position:"Body" name:"HealthCheckConfig"  type:"Struct"`
	AddressIPVersion        string                             `position:"Body" name:"AddressIPVersion"`
	Scheduler               string                             `position:"Body" name:"Scheduler"`
	ResourceGroupId         string                             `position:"Body" name:"ResourceGroupId"`
	Protocol                string                             `position:"Body" name:"Protocol"`
	PersistenceEnabled      requests.Boolean                   `position:"Body" name:"PersistenceEnabled"`
	PersistenceTimeout      requests.Integer                   `position:"Body" name:"PersistenceTimeout"`
	DryRun                  requests.Boolean                   `position:"Body" name:"DryRun"`
	ConnectionDrainEnabled  requests.Boolean                   `position:"Body" name:"ConnectionDrainEnabled"`
	ConnectionDrainTimeout  requests.Integer                   `position:"Body" name:"ConnectionDrainTimeout"`
	AnyPortEnabled          requests.Boolean                   `position:"Body" name:"AnyPortEnabled"`
	ServerGroupType         string                             `position:"Body" name:"ServerGroupType"`
	VpcId                   string                             `position:"Body" name:"VpcId"`
}

CreateServerGroupRequest is the request struct for api CreateServerGroup

func CreateCreateServerGroupRequest

func CreateCreateServerGroupRequest() (request *CreateServerGroupRequest)

CreateCreateServerGroupRequest creates a request to invoke CreateServerGroup API

type CreateServerGroupResponse

type CreateServerGroupResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ServerGroupId  string `json:"ServerGroupId" xml:"ServerGroupId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

CreateServerGroupResponse is the response struct for api CreateServerGroup

func CreateCreateServerGroupResponse

func CreateCreateServerGroupResponse() (response *CreateServerGroupResponse)

CreateCreateServerGroupResponse creates a response to parse from CreateServerGroup response

type DeleteListenerRequest

type DeleteListenerRequest struct {
	*requests.RpcRequest
	ClientToken string           `position:"Body" name:"ClientToken"`
	ListenerId  string           `position:"Body" name:"ListenerId"`
	DryRun      requests.Boolean `position:"Body" name:"DryRun"`
}

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"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

DeleteListenerResponse is the response struct for api DeleteListener

func CreateDeleteListenerResponse

func CreateDeleteListenerResponse() (response *DeleteListenerResponse)

CreateDeleteListenerResponse creates a response to parse from DeleteListener response

type DeleteLoadBalancerRequest

type DeleteLoadBalancerRequest struct {
	*requests.RpcRequest
	ClientToken    string           `position:"Body" name:"ClientToken"`
	DryRun         requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId string           `position:"Body" name:"LoadBalancerId"`
}

DeleteLoadBalancerRequest is the request struct for api DeleteLoadBalancer

func CreateDeleteLoadBalancerRequest

func CreateDeleteLoadBalancerRequest() (request *DeleteLoadBalancerRequest)

CreateDeleteLoadBalancerRequest creates a request to invoke DeleteLoadBalancer API

type DeleteLoadBalancerResponse

type DeleteLoadBalancerResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

DeleteLoadBalancerResponse is the response struct for api DeleteLoadBalancer

func CreateDeleteLoadBalancerResponse

func CreateDeleteLoadBalancerResponse() (response *DeleteLoadBalancerResponse)

CreateDeleteLoadBalancerResponse creates a response to parse from DeleteLoadBalancer response

type DeleteSecurityPolicyRequest

type DeleteSecurityPolicyRequest struct {
	*requests.RpcRequest
	ClientToken      string           `position:"Body" name:"ClientToken"`
	DryRun           requests.Boolean `position:"Body" name:"DryRun"`
	SecurityPolicyId string           `position:"Body" name:"SecurityPolicyId"`
}

DeleteSecurityPolicyRequest is the request struct for api DeleteSecurityPolicy

func CreateDeleteSecurityPolicyRequest

func CreateDeleteSecurityPolicyRequest() (request *DeleteSecurityPolicyRequest)

CreateDeleteSecurityPolicyRequest creates a request to invoke DeleteSecurityPolicy API

type DeleteSecurityPolicyResponse

type DeleteSecurityPolicyResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

DeleteSecurityPolicyResponse is the response struct for api DeleteSecurityPolicy

func CreateDeleteSecurityPolicyResponse

func CreateDeleteSecurityPolicyResponse() (response *DeleteSecurityPolicyResponse)

CreateDeleteSecurityPolicyResponse creates a response to parse from DeleteSecurityPolicy response

type DeleteServerGroupRequest

type DeleteServerGroupRequest struct {
	*requests.RpcRequest
	ClientToken   string           `position:"Body" name:"ClientToken"`
	ServerGroupId string           `position:"Body" name:"ServerGroupId"`
	DryRun        requests.Boolean `position:"Body" name:"DryRun"`
}

DeleteServerGroupRequest is the request struct for api DeleteServerGroup

func CreateDeleteServerGroupRequest

func CreateDeleteServerGroupRequest() (request *DeleteServerGroupRequest)

CreateDeleteServerGroupRequest creates a request to invoke DeleteServerGroup API

type DeleteServerGroupResponse

type DeleteServerGroupResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ServerGroupId  string `json:"ServerGroupId" xml:"ServerGroupId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

DeleteServerGroupResponse is the response struct for api DeleteServerGroup

func CreateDeleteServerGroupResponse

func CreateDeleteServerGroupResponse() (response *DeleteServerGroupResponse)

CreateDeleteServerGroupResponse creates a response to parse from DeleteServerGroup response

type DeletionProtectionConfig

type DeletionProtectionConfig struct {
	Reason      string `json:"Reason" xml:"Reason"`
	Enabled     bool   `json:"Enabled" xml:"Enabled"`
	EnabledTime string `json:"EnabledTime" xml:"EnabledTime"`
}

DeletionProtectionConfig is a nested struct in nlb response

type DescribeRegionsRequest

type DescribeRegionsRequest struct {
	*requests.RpcRequest
	ClientToken    string `position:"Body" name:"ClientToken"`
	ServiceCode    string `position:"Query" name:"ServiceCode"`
	AcceptLanguage string `position:"Query" name:"AcceptLanguage"`
}

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"`
	Success        bool     `json:"Success" xml:"Success"`
	Code           string   `json:"Code" xml:"Code"`
	Message        string   `json:"Message" xml:"Message"`
	HttpStatusCode int      `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string   `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string   `json:"DynamicMessage" xml:"DynamicMessage"`
	Regions        []Region `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 DescribeZonesRequest

type DescribeZonesRequest struct {
	*requests.RpcRequest
	ClientToken    string `position:"Query" name:"ClientToken"`
	ServiceCode    string `position:"Query" name:"ServiceCode"`
	AcceptLanguage string `position:"Query" name:"AcceptLanguage"`
}

DescribeZonesRequest is the request struct for api DescribeZones

func CreateDescribeZonesRequest

func CreateDescribeZonesRequest() (request *DescribeZonesRequest)

CreateDescribeZonesRequest creates a request to invoke DescribeZones API

type DescribeZonesResponse

type DescribeZonesResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Zones          []Zone `json:"Zones" xml:"Zones"`
}

DescribeZonesResponse is the response struct for api DescribeZones

func CreateDescribeZonesResponse

func CreateDescribeZonesResponse() (response *DescribeZonesResponse)

CreateDescribeZonesResponse creates a response to parse from DescribeZones response

type DetachCommonBandwidthPackageFromLoadBalancerRequest

type DetachCommonBandwidthPackageFromLoadBalancerRequest struct {
	*requests.RpcRequest
	ClientToken        string           `position:"Body" name:"ClientToken"`
	BandwidthPackageId string           `position:"Body" name:"BandwidthPackageId"`
	DryRun             requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId     string           `position:"Body" name:"LoadBalancerId"`
}

DetachCommonBandwidthPackageFromLoadBalancerRequest is the request struct for api DetachCommonBandwidthPackageFromLoadBalancer

func CreateDetachCommonBandwidthPackageFromLoadBalancerRequest

func CreateDetachCommonBandwidthPackageFromLoadBalancerRequest() (request *DetachCommonBandwidthPackageFromLoadBalancerRequest)

CreateDetachCommonBandwidthPackageFromLoadBalancerRequest creates a request to invoke DetachCommonBandwidthPackageFromLoadBalancer API

type DetachCommonBandwidthPackageFromLoadBalancerResponse

type DetachCommonBandwidthPackageFromLoadBalancerResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

DetachCommonBandwidthPackageFromLoadBalancerResponse is the response struct for api DetachCommonBandwidthPackageFromLoadBalancer

func CreateDetachCommonBandwidthPackageFromLoadBalancerResponse

func CreateDetachCommonBandwidthPackageFromLoadBalancerResponse() (response *DetachCommonBandwidthPackageFromLoadBalancerResponse)

CreateDetachCommonBandwidthPackageFromLoadBalancerResponse creates a response to parse from DetachCommonBandwidthPackageFromLoadBalancer response

type DisableLoadBalancerIpv6InternetRequest

type DisableLoadBalancerIpv6InternetRequest struct {
	*requests.RpcRequest
	ClientToken    string           `position:"Body" name:"ClientToken"`
	DryRun         requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId string           `position:"Body" name:"LoadBalancerId"`
}

DisableLoadBalancerIpv6InternetRequest is the request struct for api DisableLoadBalancerIpv6Internet

func CreateDisableLoadBalancerIpv6InternetRequest

func CreateDisableLoadBalancerIpv6InternetRequest() (request *DisableLoadBalancerIpv6InternetRequest)

CreateDisableLoadBalancerIpv6InternetRequest creates a request to invoke DisableLoadBalancerIpv6Internet API

type DisableLoadBalancerIpv6InternetResponse

type DisableLoadBalancerIpv6InternetResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

DisableLoadBalancerIpv6InternetResponse is the response struct for api DisableLoadBalancerIpv6Internet

func CreateDisableLoadBalancerIpv6InternetResponse

func CreateDisableLoadBalancerIpv6InternetResponse() (response *DisableLoadBalancerIpv6InternetResponse)

CreateDisableLoadBalancerIpv6InternetResponse creates a response to parse from DisableLoadBalancerIpv6Internet response

type EnableLoadBalancerIpv6InternetRequest

type EnableLoadBalancerIpv6InternetRequest struct {
	*requests.RpcRequest
	ClientToken    string           `position:"Body" name:"ClientToken"`
	DryRun         requests.Boolean `position:"Body" name:"DryRun"`
	LoadBalancerId string           `position:"Body" name:"LoadBalancerId"`
}

EnableLoadBalancerIpv6InternetRequest is the request struct for api EnableLoadBalancerIpv6Internet

func CreateEnableLoadBalancerIpv6InternetRequest

func CreateEnableLoadBalancerIpv6InternetRequest() (request *EnableLoadBalancerIpv6InternetRequest)

CreateEnableLoadBalancerIpv6InternetRequest creates a request to invoke EnableLoadBalancerIpv6Internet API

type EnableLoadBalancerIpv6InternetResponse

type EnableLoadBalancerIpv6InternetResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

EnableLoadBalancerIpv6InternetResponse is the response struct for api EnableLoadBalancerIpv6Internet

func CreateEnableLoadBalancerIpv6InternetResponse

func CreateEnableLoadBalancerIpv6InternetResponse() (response *EnableLoadBalancerIpv6InternetResponse)

CreateEnableLoadBalancerIpv6InternetResponse creates a response to parse from EnableLoadBalancerIpv6Internet response

type GetJobStatusRequest

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

GetJobStatusRequest is the request struct for api GetJobStatus

func CreateGetJobStatusRequest

func CreateGetJobStatusRequest() (request *GetJobStatusRequest)

CreateGetJobStatusRequest creates a request to invoke GetJobStatus API

type GetJobStatusResponse

type GetJobStatusResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	Status         string `json:"Status" xml:"Status"`
}

GetJobStatusResponse is the response struct for api GetJobStatus

func CreateGetJobStatusResponse

func CreateGetJobStatusResponse() (response *GetJobStatusResponse)

CreateGetJobStatusResponse creates a response to parse from GetJobStatus response

type GetListenerAttributeRequest

type GetListenerAttributeRequest struct {
	*requests.RpcRequest
	ClientToken string           `position:"Query" name:"ClientToken"`
	ListenerId  string           `position:"Query" name:"ListenerId"`
	DryRun      requests.Boolean `position:"Query" name:"DryRun"`
}

GetListenerAttributeRequest is the request struct for api GetListenerAttribute

func CreateGetListenerAttributeRequest

func CreateGetListenerAttributeRequest() (request *GetListenerAttributeRequest)

CreateGetListenerAttributeRequest creates a request to invoke GetListenerAttribute API

type GetListenerAttributeResponse

type GetListenerAttributeResponse struct {
	*responses.BaseResponse
	RequestId            string   `json:"RequestId" xml:"RequestId"`
	Success              bool     `json:"Success" xml:"Success"`
	Code                 string   `json:"Code" xml:"Code"`
	Message              string   `json:"Message" xml:"Message"`
	HttpStatusCode       int      `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode          string   `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage       string   `json:"DynamicMessage" xml:"DynamicMessage"`
	RegionId             string   `json:"RegionId" xml:"RegionId"`
	LoadBalancerId       string   `json:"LoadBalancerId" xml:"LoadBalancerId"`
	ListenerId           string   `json:"ListenerId" xml:"ListenerId"`
	ListenerProtocol     string   `json:"ListenerProtocol" xml:"ListenerProtocol"`
	ListenerPort         int      `json:"ListenerPort" xml:"ListenerPort"`
	StartPort            string   `json:"StartPort" xml:"StartPort"`
	EndPort              string   `json:"EndPort" xml:"EndPort"`
	ListenerDescription  string   `json:"ListenerDescription" xml:"ListenerDescription"`
	ServerGroupId        string   `json:"ServerGroupId" xml:"ServerGroupId"`
	IdleTimeout          int      `json:"IdleTimeout" xml:"IdleTimeout"`
	SecurityPolicyId     string   `json:"SecurityPolicyId" xml:"SecurityPolicyId"`
	CaEnabled            bool     `json:"CaEnabled" xml:"CaEnabled"`
	AlpnEnabled          bool     `json:"AlpnEnabled" xml:"AlpnEnabled"`
	AlpnPolicy           string   `json:"AlpnPolicy" xml:"AlpnPolicy"`
	ProxyProtocolEnabled bool     `json:"ProxyProtocolEnabled" xml:"ProxyProtocolEnabled"`
	SecSensorEnabled     bool     `json:"SecSensorEnabled" xml:"SecSensorEnabled"`
	ListenerStatus       string   `json:"ListenerStatus" xml:"ListenerStatus"`
	Cps                  int      `json:"Cps" xml:"Cps"`
	Mss                  int      `json:"Mss" xml:"Mss"`
	CertificateIds       []string `json:"CertificateIds" xml:"CertificateIds"`
	CaCertificateIds     []string `json:"CaCertificateIds" xml:"CaCertificateIds"`
}

GetListenerAttributeResponse is the response struct for api GetListenerAttribute

func CreateGetListenerAttributeResponse

func CreateGetListenerAttributeResponse() (response *GetListenerAttributeResponse)

CreateGetListenerAttributeResponse creates a response to parse from GetListenerAttribute response

type GetListenerHealthStatusRequest

type GetListenerHealthStatusRequest struct {
	*requests.RpcRequest
	ListenerId string           `position:"Query" name:"ListenerId"`
	NextToken  string           `position:"Query" name:"NextToken"`
	MaxResults requests.Integer `position:"Query" name:"MaxResults"`
}

GetListenerHealthStatusRequest is the request struct for api GetListenerHealthStatus

func CreateGetListenerHealthStatusRequest

func CreateGetListenerHealthStatusRequest() (request *GetListenerHealthStatusRequest)

CreateGetListenerHealthStatusRequest creates a request to invoke GetListenerHealthStatus API

type GetListenerHealthStatusResponse

type GetListenerHealthStatusResponse struct {
	*responses.BaseResponse
	RequestId            string                     `json:"RequestId" xml:"RequestId"`
	Success              bool                       `json:"Success" xml:"Success"`
	Code                 string                     `json:"Code" xml:"Code"`
	Message              string                     `json:"Message" xml:"Message"`
	HttpStatusCode       int                        `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode          string                     `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage       string                     `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount           int                        `json:"TotalCount" xml:"TotalCount"`
	NextToken            string                     `json:"NextToken" xml:"NextToken"`
	MaxResults           int                        `json:"MaxResults" xml:"MaxResults"`
	ListenerHealthStatus []ListenerHealthStatusItem `json:"ListenerHealthStatus" xml:"ListenerHealthStatus"`
}

GetListenerHealthStatusResponse is the response struct for api GetListenerHealthStatus

func CreateGetListenerHealthStatusResponse

func CreateGetListenerHealthStatusResponse() (response *GetListenerHealthStatusResponse)

CreateGetListenerHealthStatusResponse creates a response to parse from GetListenerHealthStatus response

type GetLoadBalancerAttributeRequest

type GetLoadBalancerAttributeRequest struct {
	*requests.RpcRequest
	ClientToken    string           `position:"Query" name:"ClientToken"`
	DryRun         requests.Boolean `position:"Query" name:"DryRun"`
	LoadBalancerId string           `position:"Query" name:"LoadBalancerId"`
}

GetLoadBalancerAttributeRequest is the request struct for api GetLoadBalancerAttribute

func CreateGetLoadBalancerAttributeRequest

func CreateGetLoadBalancerAttributeRequest() (request *GetLoadBalancerAttributeRequest)

CreateGetLoadBalancerAttributeRequest creates a request to invoke GetLoadBalancerAttribute API

type GetLoadBalancerAttributeResponse

type GetLoadBalancerAttributeResponse struct {
	*responses.BaseResponse
	RequestId                    string                       `json:"RequestId" xml:"RequestId"`
	Success                      bool                         `json:"Success" xml:"Success"`
	Code                         string                       `json:"Code" xml:"Code"`
	Message                      string                       `json:"Message" xml:"Message"`
	HttpStatusCode               int                          `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode                  string                       `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage               string                       `json:"DynamicMessage" xml:"DynamicMessage"`
	RegionId                     string                       `json:"RegionId" xml:"RegionId"`
	LoadBalancerId               string                       `json:"LoadBalancerId" xml:"LoadBalancerId"`
	LoadBalancerName             string                       `json:"LoadBalancerName" xml:"LoadBalancerName"`
	LoadBalancerType             string                       `json:"LoadBalancerType" xml:"LoadBalancerType"`
	AddressType                  string                       `json:"AddressType" xml:"AddressType"`
	AddressIpVersion             string                       `json:"AddressIpVersion" xml:"AddressIpVersion"`
	Ipv6AddressType              string                       `json:"Ipv6AddressType" xml:"Ipv6AddressType"`
	LoadBalancerStatus           string                       `json:"LoadBalancerStatus" xml:"LoadBalancerStatus"`
	LoadBalancerBusinessStatus   string                       `json:"LoadBalancerBusinessStatus" xml:"LoadBalancerBusinessStatus"`
	VpcId                        string                       `json:"VpcId" xml:"VpcId"`
	CapacityUnitCount            int64                        `json:"CapacityUnitCount" xml:"CapacityUnitCount"`
	CreateTime                   string                       `json:"CreateTime" xml:"CreateTime"`
	ResourceGroupId              string                       `json:"ResourceGroupId" xml:"ResourceGroupId"`
	DNSName                      string                       `json:"DNSName" xml:"DNSName"`
	BandwidthPackageId           string                       `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	CrossZoneEnabled             bool                         `json:"CrossZoneEnabled" xml:"CrossZoneEnabled"`
	TrafficAffinityEnabled       bool                         `json:"TrafficAffinityEnabled" xml:"TrafficAffinityEnabled"`
	Cps                          int                          `json:"Cps" xml:"Cps"`
	SysSecurityGroupId           string                       `json:"SysSecurityGroupId" xml:"SysSecurityGroupId"`
	SecurityGroupIds             []string                     `json:"SecurityGroupIds" xml:"SecurityGroupIds"`
	LoadBalancerBillingConfig    LoadBalancerBillingConfig    `json:"LoadBalancerBillingConfig" xml:"LoadBalancerBillingConfig"`
	DeletionProtectionConfig     DeletionProtectionConfig     `json:"DeletionProtectionConfig" xml:"DeletionProtectionConfig"`
	ModificationProtectionConfig ModificationProtectionConfig `json:"ModificationProtectionConfig" xml:"ModificationProtectionConfig"`
	OperationLocks               []OperationLock              `json:"OperationLocks" xml:"OperationLocks"`
	ZoneMappings                 []ZoneMapping                `json:"ZoneMappings" xml:"ZoneMappings"`
}

GetLoadBalancerAttributeResponse is the response struct for api GetLoadBalancerAttribute

func CreateGetLoadBalancerAttributeResponse

func CreateGetLoadBalancerAttributeResponse() (response *GetLoadBalancerAttributeResponse)

CreateGetLoadBalancerAttributeResponse creates a response to parse from GetLoadBalancerAttribute response

type HealthCheck

type HealthCheck struct {
	HealthCheckEnabled        bool     `json:"HealthCheckEnabled" xml:"HealthCheckEnabled"`
	HealthCheckType           string   `json:"HealthCheckType" xml:"HealthCheckType"`
	HealthCheckConnectPort    int      `json:"HealthCheckConnectPort" xml:"HealthCheckConnectPort"`
	HealthyThreshold          int      `json:"HealthyThreshold" xml:"HealthyThreshold"`
	UnhealthyThreshold        int      `json:"UnhealthyThreshold" xml:"UnhealthyThreshold"`
	HealthCheckConnectTimeout int      `json:"HealthCheckConnectTimeout" xml:"HealthCheckConnectTimeout"`
	HealthCheckInterval       int      `json:"HealthCheckInterval" xml:"HealthCheckInterval"`
	HealthCheckDomain         string   `json:"HealthCheckDomain" xml:"HealthCheckDomain"`
	HealthCheckUrl            string   `json:"HealthCheckUrl" xml:"HealthCheckUrl"`
	HttpCheckMethod           string   `json:"HttpCheckMethod" xml:"HttpCheckMethod"`
	HealthCheckHttpCode       []string `json:"HealthCheckHttpCode" xml:"HealthCheckHttpCode"`
}

HealthCheck is a nested struct in nlb response

type HealthCheckHttpCode

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

HealthCheckHttpCode is a nested struct in nlb response

type ListListenerCertificatesRequest

type ListListenerCertificatesRequest struct {
	*requests.RpcRequest
	ListenerId string           `position:"Body" name:"ListenerId"`
	NextToken  string           `position:"Body" name:"NextToken"`
	PageSize   requests.Integer `position:"Body" name:"PageSize"`
	MaxResults requests.Integer `position:"Body" name:"MaxResults"`
	Page       requests.Integer `position:"Body" name:"Page"`
}

ListListenerCertificatesRequest is the request struct for api ListListenerCertificates

func CreateListListenerCertificatesRequest

func CreateListListenerCertificatesRequest() (request *ListListenerCertificatesRequest)

CreateListListenerCertificatesRequest creates a request to invoke ListListenerCertificates API

type ListListenerCertificatesResponse

type ListListenerCertificatesResponse struct {
	*responses.BaseResponse
	RequestId      string   `json:"RequestId" xml:"RequestId"`
	Success        bool     `json:"Success" xml:"Success"`
	Code           string   `json:"Code" xml:"Code"`
	Message        string   `json:"Message" xml:"Message"`
	HttpStatusCode int      `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string   `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string   `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount     int      `json:"TotalCount" xml:"TotalCount"`
	NextToken      string   `json:"NextToken" xml:"NextToken"`
	MaxResults     int      `json:"MaxResults" xml:"MaxResults"`
	CertificateIds []string `json:"CertificateIds" xml:"CertificateIds"`
}

ListListenerCertificatesResponse is the response struct for api ListListenerCertificates

func CreateListListenerCertificatesResponse

func CreateListListenerCertificatesResponse() (response *ListListenerCertificatesResponse)

CreateListListenerCertificatesResponse creates a response to parse from ListListenerCertificates response

type ListListenersRequest

type ListListenersRequest struct {
	*requests.RpcRequest
	LoadBalancerIds  *[]string        `position:"Query" name:"LoadBalancerIds"  type:"Repeated"`
	NextToken        string           `position:"Query" name:"NextToken"`
	ListenerProtocol string           `position:"Query" name:"ListenerProtocol"`
	ListenerIds      *[]string        `position:"Query" name:"ListenerIds"  type:"Repeated"`
	MaxResults       requests.Integer `position:"Query" name:"MaxResults"`
}

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
	RequestId      string         `json:"RequestId" xml:"RequestId"`
	Success        bool           `json:"Success" xml:"Success"`
	Code           string         `json:"Code" xml:"Code"`
	Message        string         `json:"Message" xml:"Message"`
	HttpStatusCode int            `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string         `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string         `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount     int            `json:"TotalCount" xml:"TotalCount"`
	NextToken      string         `json:"NextToken" xml:"NextToken"`
	MaxResults     int            `json:"MaxResults" xml:"MaxResults"`
	Listeners      []ListenerInfo `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 ListLoadBalancersRequest

type ListLoadBalancersRequest struct {
	*requests.RpcRequest
	LoadBalancerNames          *[]string               `position:"Query" name:"LoadBalancerNames"  type:"Repeated"`
	LoadBalancerIds            *[]string               `position:"Query" name:"LoadBalancerIds"  type:"Repeated"`
	AddressIpVersion           string                  `position:"Query" name:"AddressIpVersion"`
	ResourceGroupId            string                  `position:"Query" name:"ResourceGroupId"`
	NextToken                  string                  `position:"Query" name:"NextToken"`
	DNSName                    string                  `position:"Query" name:"DNSName"`
	AddressType                string                  `position:"Query" name:"AddressType"`
	Tag                        *[]ListLoadBalancersTag `position:"Query" name:"Tag"  type:"Repeated"`
	VpcIds                     *[]string               `position:"Query" name:"VpcIds"  type:"Repeated"`
	Address                    string                  `position:"Query" name:"Address"`
	LoadBalancerBusinessStatus string                  `position:"Query" name:"LoadBalancerBusinessStatus"`
	LoadBalancerStatus         string                  `position:"Query" name:"LoadBalancerStatus"`
	LoadBalancerType           string                  `position:"Query" name:"LoadBalancerType"`
	ZoneId                     string                  `position:"Query" name:"ZoneId"`
	MaxResults                 requests.Integer        `position:"Query" name:"MaxResults"`
	Ipv6AddressType            string                  `position:"Query" name:"Ipv6AddressType"`
}

ListLoadBalancersRequest is the request struct for api ListLoadBalancers

func CreateListLoadBalancersRequest

func CreateListLoadBalancersRequest() (request *ListLoadBalancersRequest)

CreateListLoadBalancersRequest creates a request to invoke ListLoadBalancers API

type ListLoadBalancersResponse

type ListLoadBalancersResponse struct {
	*responses.BaseResponse
	RequestId      string             `json:"RequestId" xml:"RequestId"`
	Success        bool               `json:"Success" xml:"Success"`
	Code           string             `json:"Code" xml:"Code"`
	Message        string             `json:"Message" xml:"Message"`
	HttpStatusCode int                `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string             `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string             `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount     int                `json:"TotalCount" xml:"TotalCount"`
	NextToken      string             `json:"NextToken" xml:"NextToken"`
	MaxResults     int                `json:"MaxResults" xml:"MaxResults"`
	LoadBalancers  []LoadbalancerInfo `json:"LoadBalancers" xml:"LoadBalancers"`
}

ListLoadBalancersResponse is the response struct for api ListLoadBalancers

func CreateListLoadBalancersResponse

func CreateListLoadBalancersResponse() (response *ListLoadBalancersResponse)

CreateListLoadBalancersResponse creates a response to parse from ListLoadBalancers response

type ListLoadBalancersTag

type ListLoadBalancersTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListLoadBalancersTag is a repeated param struct in ListLoadBalancersRequest

type ListSecurityPolicyRequest

type ListSecurityPolicyRequest struct {
	*requests.RpcRequest
	SecurityPolicyNames *[]string                `position:"Body" name:"SecurityPolicyNames"  type:"Repeated"`
	ResourceGroupId     string                   `position:"Body" name:"ResourceGroupId"`
	NextToken           string                   `position:"Body" name:"NextToken"`
	Tag                 *[]ListSecurityPolicyTag `position:"Query" name:"Tag"  type:"Repeated"`
	SecurityPolicyIds   *[]string                `position:"Body" name:"SecurityPolicyIds"  type:"Repeated"`
	MaxResults          requests.Integer         `position:"Body" name:"MaxResults"`
}

ListSecurityPolicyRequest is the request struct for api ListSecurityPolicy

func CreateListSecurityPolicyRequest

func CreateListSecurityPolicyRequest() (request *ListSecurityPolicyRequest)

CreateListSecurityPolicyRequest creates a request to invoke ListSecurityPolicy API

type ListSecurityPolicyResponse

type ListSecurityPolicyResponse struct {
	*responses.BaseResponse
	RequestId        string            `json:"RequestId" xml:"RequestId"`
	Success          bool              `json:"Success" xml:"Success"`
	Code             string            `json:"Code" xml:"Code"`
	Message          string            `json:"Message" xml:"Message"`
	HttpStatusCode   int               `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode      string            `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage   string            `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount       int               `json:"TotalCount" xml:"TotalCount"`
	NextToken        string            `json:"NextToken" xml:"NextToken"`
	MaxResults       int               `json:"MaxResults" xml:"MaxResults"`
	SecurityPolicies []SecurityPolicie `json:"SecurityPolicies" xml:"SecurityPolicies"`
}

ListSecurityPolicyResponse is the response struct for api ListSecurityPolicy

func CreateListSecurityPolicyResponse

func CreateListSecurityPolicyResponse() (response *ListSecurityPolicyResponse)

CreateListSecurityPolicyResponse creates a response to parse from ListSecurityPolicy response

type ListSecurityPolicyTag

type ListSecurityPolicyTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListSecurityPolicyTag is a repeated param struct in ListSecurityPolicyRequest

type ListServerGroupServersRequest

type ListServerGroupServersRequest struct {
	*requests.RpcRequest
	ServerGroupId string           `position:"Body" name:"ServerGroupId"`
	NextToken     string           `position:"Body" name:"NextToken"`
	ServerIds     *[]string        `position:"Body" name:"ServerIds"  type:"Repeated"`
	ServerIps     *[]string        `position:"Body" name:"ServerIps"  type:"Repeated"`
	MaxResults    requests.Integer `position:"Body" name:"MaxResults"`
}

ListServerGroupServersRequest is the request struct for api ListServerGroupServers

func CreateListServerGroupServersRequest

func CreateListServerGroupServersRequest() (request *ListServerGroupServersRequest)

CreateListServerGroupServersRequest creates a request to invoke ListServerGroupServers API

type ListServerGroupServersResponse

type ListServerGroupServersResponse struct {
	*responses.BaseResponse
	RequestId      string   `json:"RequestId" xml:"RequestId"`
	Success        bool     `json:"Success" xml:"Success"`
	Code           string   `json:"Code" xml:"Code"`
	Message        string   `json:"Message" xml:"Message"`
	HttpStatusCode int      `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string   `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string   `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount     int      `json:"TotalCount" xml:"TotalCount"`
	NextToken      string   `json:"NextToken" xml:"NextToken"`
	MaxResults     int      `json:"MaxResults" xml:"MaxResults"`
	Servers        []Server `json:"Servers" xml:"Servers"`
}

ListServerGroupServersResponse is the response struct for api ListServerGroupServers

func CreateListServerGroupServersResponse

func CreateListServerGroupServersResponse() (response *ListServerGroupServersResponse)

CreateListServerGroupServersResponse creates a response to parse from ListServerGroupServers response

type ListServerGroupsRequest

type ListServerGroupsRequest struct {
	*requests.RpcRequest
	ServerGroupNames *[]string              `position:"Body" name:"ServerGroupNames"  type:"Repeated"`
	ResourceGroupId  string                 `position:"Body" name:"ResourceGroupId"`
	NextToken        string                 `position:"Body" name:"NextToken"`
	Tag              *[]ListServerGroupsTag `position:"Query" name:"Tag"  type:"Repeated"`
	ServerGroupIds   *[]string              `position:"Body" name:"ServerGroupIds"  type:"Repeated"`
	ServerGroupType  string                 `position:"Body" name:"ServerGroupType"`
	VpcId            string                 `position:"Body" name:"VpcId"`
	MaxResults       requests.Integer       `position:"Body" name:"MaxResults"`
}

ListServerGroupsRequest is the request struct for api ListServerGroups

func CreateListServerGroupsRequest

func CreateListServerGroupsRequest() (request *ListServerGroupsRequest)

CreateListServerGroupsRequest creates a request to invoke ListServerGroups API

type ListServerGroupsResponse

type ListServerGroupsResponse struct {
	*responses.BaseResponse
	RequestId      string        `json:"RequestId" xml:"RequestId"`
	Success        bool          `json:"Success" xml:"Success"`
	Code           string        `json:"Code" xml:"Code"`
	Message        string        `json:"Message" xml:"Message"`
	HttpStatusCode int           `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string        `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string        `json:"DynamicMessage" xml:"DynamicMessage"`
	TotalCount     int           `json:"TotalCount" xml:"TotalCount"`
	NextToken      string        `json:"NextToken" xml:"NextToken"`
	MaxResults     int           `json:"MaxResults" xml:"MaxResults"`
	ServerGroups   []ServerGroup `json:"ServerGroups" xml:"ServerGroups"`
}

ListServerGroupsResponse is the response struct for api ListServerGroups

func CreateListServerGroupsResponse

func CreateListServerGroupsResponse() (response *ListServerGroupsResponse)

CreateListServerGroupsResponse creates a response to parse from ListServerGroups response

type ListServerGroupsTag

type ListServerGroupsTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListServerGroupsTag is a repeated param struct in ListServerGroupsRequest

type ListSystemSecurityPolicyRequest

type ListSystemSecurityPolicyRequest struct {
	*requests.RpcRequest
	Channel              string `position:"Body" name:"Channel"`
	OwnerIdLoginEmail    string `position:"Body" name:"OwnerIdLoginEmail"`
	CallerBidLoginEmail  string `position:"Body" name:"CallerBidLoginEmail"`
	CallerUidLoginEmail  string `position:"Body" name:"CallerUidLoginEmail"`
	RequestContent       string `position:"Body" name:"RequestContent"`
	ResourceOwnerAccount string `position:"Body" name:"ResourceOwnerAccount"`
	OwnerAccount         string `position:"Body" name:"OwnerAccount"`
}

ListSystemSecurityPolicyRequest is the request struct for api ListSystemSecurityPolicy

func CreateListSystemSecurityPolicyRequest

func CreateListSystemSecurityPolicyRequest() (request *ListSystemSecurityPolicyRequest)

CreateListSystemSecurityPolicyRequest creates a request to invoke ListSystemSecurityPolicy API

type ListSystemSecurityPolicyResponse

type ListSystemSecurityPolicyResponse struct {
	*responses.BaseResponse
	RequestId        string            `json:"RequestId" xml:"RequestId"`
	Success          bool              `json:"Success" xml:"Success"`
	Code             string            `json:"Code" xml:"Code"`
	Message          string            `json:"Message" xml:"Message"`
	HttpStatusCode   int               `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode      string            `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage   string            `json:"DynamicMessage" xml:"DynamicMessage"`
	SecurityPolicies []SecurityPolicie `json:"SecurityPolicies" xml:"SecurityPolicies"`
}

ListSystemSecurityPolicyResponse is the response struct for api ListSystemSecurityPolicy

func CreateListSystemSecurityPolicyResponse

func CreateListSystemSecurityPolicyResponse() (response *ListSystemSecurityPolicyResponse)

CreateListSystemSecurityPolicyResponse creates a response to parse from ListSystemSecurityPolicy response

type ListTagResourcesRequest

type ListTagResourcesRequest struct {
	*requests.RpcRequest
	NextToken    string                 `position:"Body" name:"NextToken"`
	PageSize     requests.Integer       `position:"Body" name:"PageSize"`
	Tag          *[]ListTagResourcesTag `position:"Body" name:"Tag"  type:"Repeated"`
	ResourceId   *[]string              `position:"Body" name:"ResourceId"  type:"Repeated"`
	ResourceType string                 `position:"Body" name:"ResourceType"`
	MaxResults   requests.Integer       `position:"Body" name:"MaxResults"`
	Page         requests.Integer       `position:"Body" name:"Page"`
}

ListTagResourcesRequest is the request struct for api ListTagResources

func CreateListTagResourcesRequest

func CreateListTagResourcesRequest() (request *ListTagResourcesRequest)

CreateListTagResourcesRequest creates a request to invoke ListTagResources API

type ListTagResourcesResponse

type ListTagResourcesResponse struct {
	*responses.BaseResponse
	RequestId    string               `json:"RequestId" xml:"RequestId"`
	TotalCount   int                  `json:"TotalCount" xml:"TotalCount"`
	NextToken    string               `json:"NextToken" xml:"NextToken"`
	MaxResults   int                  `json:"MaxResults" xml:"MaxResults"`
	TagResources []TagResultModelList `json:"TagResources" xml:"TagResources"`
}

ListTagResourcesResponse is the response struct for api ListTagResources

func CreateListTagResourcesResponse

func CreateListTagResourcesResponse() (response *ListTagResourcesResponse)

CreateListTagResourcesResponse creates a response to parse from ListTagResources response

type ListTagResourcesTag

type ListTagResourcesTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

ListTagResourcesTag is a repeated param struct in ListTagResourcesRequest

type ListenerHealthStatus

type ListenerHealthStatus struct {
	ListenerHealthStatusItem []ListenerHealthStatusItem `json:"ListenerHealthStatus" xml:"ListenerHealthStatus"`
}

ListenerHealthStatus is a nested struct in nlb response

type ListenerHealthStatusItem

type ListenerHealthStatusItem struct {
	ListenerId       string            `json:"ListenerId" xml:"ListenerId"`
	ListenerPort     int               `json:"ListenerPort" xml:"ListenerPort"`
	ListenerProtocol string            `json:"ListenerProtocol" xml:"ListenerProtocol"`
	ServerGroupInfos []ServerGroupInfo `json:"ServerGroupInfos" xml:"ServerGroupInfos"`
}

ListenerHealthStatusItem is a nested struct in nlb response

type ListenerInfo

type ListenerInfo struct {
	LoadBalancerId       string   `json:"LoadBalancerId" xml:"LoadBalancerId"`
	ListenerId           string   `json:"ListenerId" xml:"ListenerId"`
	ListenerProtocol     string   `json:"ListenerProtocol" xml:"ListenerProtocol"`
	ListenerPort         int      `json:"ListenerPort" xml:"ListenerPort"`
	StartPort            string   `json:"StartPort" xml:"StartPort"`
	EndPort              string   `json:"EndPort" xml:"EndPort"`
	ListenerDescription  string   `json:"ListenerDescription" xml:"ListenerDescription"`
	ServerGroupId        string   `json:"ServerGroupId" xml:"ServerGroupId"`
	IdleTimeout          int      `json:"IdleTimeout" xml:"IdleTimeout"`
	SecurityPolicyId     string   `json:"SecurityPolicyId" xml:"SecurityPolicyId"`
	CaEnabled            bool     `json:"CaEnabled" xml:"CaEnabled"`
	ListenerStatus       string   `json:"ListenerStatus" xml:"ListenerStatus"`
	RegionId             string   `json:"RegionId" xml:"RegionId"`
	AlpnEnabled          bool     `json:"AlpnEnabled" xml:"AlpnEnabled"`
	AlpnPolicy           string   `json:"AlpnPolicy" xml:"AlpnPolicy"`
	SecSensorEnabled     bool     `json:"SecSensorEnabled" xml:"SecSensorEnabled"`
	ProxyProtocolEnabled bool     `json:"ProxyProtocolEnabled" xml:"ProxyProtocolEnabled"`
	Cps                  int      `json:"Cps" xml:"Cps"`
	Mss                  int      `json:"Mss" xml:"Mss"`
	CertificateIds       []string `json:"CertificateIds" xml:"CertificateIds"`
	CaCertificateIds     []string `json:"CaCertificateIds" xml:"CaCertificateIds"`
}

ListenerInfo is a nested struct in nlb response

type Listeners

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

Listeners is a nested struct in nlb response

type LoadBalancerAddress

type LoadBalancerAddress struct {
	EniId              string `json:"EniId" xml:"EniId"`
	AllocationId       string `json:"AllocationId" xml:"AllocationId"`
	PrivateIPv4Address string `json:"PrivateIPv4Address" xml:"PrivateIPv4Address"`
	PublicIPv4Address  string `json:"PublicIPv4Address" xml:"PublicIPv4Address"`
	Ipv6Address        string `json:"Ipv6Address" xml:"Ipv6Address"`
}

LoadBalancerAddress is a nested struct in nlb response

type LoadBalancerAddressesInGetLoadBalancerAttribute

type LoadBalancerAddressesInGetLoadBalancerAttribute struct {
	LoadBalancerAddress []LoadBalancerAddress `json:"LoadBalancerAddress" xml:"LoadBalancerAddress"`
}

LoadBalancerAddressesInGetLoadBalancerAttribute is a nested struct in nlb response

type LoadBalancerAddressesInListLoadBalancers

type LoadBalancerAddressesInListLoadBalancers struct {
	LoadBalancerAddress []LoadBalancerAddress `json:"LoadBalancerAddress" xml:"LoadBalancerAddress"`
}

LoadBalancerAddressesInListLoadBalancers is a nested struct in nlb response

type LoadBalancerBillingConfig

type LoadBalancerBillingConfig struct {
	InternetBandwidth  int    `json:"InternetBandwidth" xml:"InternetBandwidth"`
	InternetChargeType string `json:"InternetChargeType" xml:"InternetChargeType"`
	PayType            string `json:"PayType" xml:"PayType"`
}

LoadBalancerBillingConfig is a nested struct in nlb response

type LoadBalancerJoinSecurityGroupRequest

type LoadBalancerJoinSecurityGroupRequest struct {
	*requests.RpcRequest
	ClientToken      string           `position:"Body" name:"ClientToken"`
	DryRun           requests.Boolean `position:"Body" name:"DryRun"`
	SecurityGroupIds *[]string        `position:"Body" name:"SecurityGroupIds"  type:"Repeated"`
	LoadBalancerId   string           `position:"Body" name:"LoadBalancerId"`
}

LoadBalancerJoinSecurityGroupRequest is the request struct for api LoadBalancerJoinSecurityGroup

func CreateLoadBalancerJoinSecurityGroupRequest

func CreateLoadBalancerJoinSecurityGroupRequest() (request *LoadBalancerJoinSecurityGroupRequest)

CreateLoadBalancerJoinSecurityGroupRequest creates a request to invoke LoadBalancerJoinSecurityGroup API

type LoadBalancerJoinSecurityGroupResponse

type LoadBalancerJoinSecurityGroupResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

LoadBalancerJoinSecurityGroupResponse is the response struct for api LoadBalancerJoinSecurityGroup

func CreateLoadBalancerJoinSecurityGroupResponse

func CreateLoadBalancerJoinSecurityGroupResponse() (response *LoadBalancerJoinSecurityGroupResponse)

CreateLoadBalancerJoinSecurityGroupResponse creates a response to parse from LoadBalancerJoinSecurityGroup response

type LoadBalancerLeaveSecurityGroupRequest

type LoadBalancerLeaveSecurityGroupRequest struct {
	*requests.RpcRequest
	ClientToken      string           `position:"Body" name:"ClientToken"`
	DryRun           requests.Boolean `position:"Body" name:"DryRun"`
	SecurityGroupIds *[]string        `position:"Body" name:"SecurityGroupIds"  type:"Repeated"`
	LoadBalancerId   string           `position:"Body" name:"LoadBalancerId"`
}

LoadBalancerLeaveSecurityGroupRequest is the request struct for api LoadBalancerLeaveSecurityGroup

func CreateLoadBalancerLeaveSecurityGroupRequest

func CreateLoadBalancerLeaveSecurityGroupRequest() (request *LoadBalancerLeaveSecurityGroupRequest)

CreateLoadBalancerLeaveSecurityGroupRequest creates a request to invoke LoadBalancerLeaveSecurityGroup API

type LoadBalancerLeaveSecurityGroupResponse

type LoadBalancerLeaveSecurityGroupResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

LoadBalancerLeaveSecurityGroupResponse is the response struct for api LoadBalancerLeaveSecurityGroup

func CreateLoadBalancerLeaveSecurityGroupResponse

func CreateLoadBalancerLeaveSecurityGroupResponse() (response *LoadBalancerLeaveSecurityGroupResponse)

CreateLoadBalancerLeaveSecurityGroupResponse creates a response to parse from LoadBalancerLeaveSecurityGroup response

type LoadBalancers

type LoadBalancers struct {
	LoadbalancerInfo []LoadbalancerInfo `json:"LoadbalancerInfo" xml:"LoadbalancerInfo"`
}

LoadBalancers is a nested struct in nlb response

type LoadbalancerInfo

type LoadbalancerInfo struct {
	RegionId                     string                       `json:"RegionId" xml:"RegionId"`
	LoadBalancerId               string                       `json:"LoadBalancerId" xml:"LoadBalancerId"`
	LoadBalancerName             string                       `json:"LoadBalancerName" xml:"LoadBalancerName"`
	LoadBalancerType             string                       `json:"LoadBalancerType" xml:"LoadBalancerType"`
	AddressType                  string                       `json:"AddressType" xml:"AddressType"`
	AddressIpVersion             string                       `json:"AddressIpVersion" xml:"AddressIpVersion"`
	Ipv6AddressType              string                       `json:"Ipv6AddressType" xml:"Ipv6AddressType"`
	LoadBalancerStatus           string                       `json:"LoadBalancerStatus" xml:"LoadBalancerStatus"`
	LoadBalancerBusinessStatus   string                       `json:"LoadBalancerBusinessStatus" xml:"LoadBalancerBusinessStatus"`
	VpcId                        string                       `json:"VpcId" xml:"VpcId"`
	CapacityUnitCount            int64                        `json:"CapacityUnitCount" xml:"CapacityUnitCount"`
	CreateTime                   string                       `json:"CreateTime" xml:"CreateTime"`
	ResourceGroupId              string                       `json:"ResourceGroupId" xml:"ResourceGroupId"`
	DNSName                      string                       `json:"DNSName" xml:"DNSName"`
	BandwidthPackageId           string                       `json:"BandwidthPackageId" xml:"BandwidthPackageId"`
	SysSecurityGroupId           string                       `json:"SysSecurityGroupId" xml:"SysSecurityGroupId"`
	CrossZoneEnabled             bool                         `json:"CrossZoneEnabled" xml:"CrossZoneEnabled"`
	TrafficAffinityEnabled       bool                         `json:"TrafficAffinityEnabled" xml:"TrafficAffinityEnabled"`
	AliUid                       int64                        `json:"AliUid" xml:"AliUid"`
	SecurityGroupIds             []string                     `json:"SecurityGroupIds" xml:"SecurityGroupIds"`
	LoadBalancerBillingConfig    LoadBalancerBillingConfig    `json:"LoadBalancerBillingConfig" xml:"LoadBalancerBillingConfig"`
	DeletionProtectionConfig     DeletionProtectionConfig     `json:"DeletionProtectionConfig" xml:"DeletionProtectionConfig"`
	ModificationProtectionConfig ModificationProtectionConfig `json:"ModificationProtectionConfig" xml:"ModificationProtectionConfig"`
	OperationLocks               []OperationLock              `json:"OperationLocks" xml:"OperationLocks"`
	ZoneMappings                 []ZoneMapping                `json:"ZoneMappings" xml:"ZoneMappings"`
	Tags                         []TagModels                  `json:"Tags" xml:"Tags"`
}

LoadbalancerInfo is a nested struct in nlb response

type ModificationProtectionConfig

type ModificationProtectionConfig struct {
	Reason      string `json:"Reason" xml:"Reason"`
	Status      string `json:"Status" xml:"Status"`
	EnabledTime string `json:"EnabledTime" xml:"EnabledTime"`
}

ModificationProtectionConfig is a nested struct in nlb response

type NonNormalServers

type NonNormalServers struct {
	AbnormalServer []AbnormalServer `json:"AbnormalServer" xml:"AbnormalServer"`
}

NonNormalServers is a nested struct in nlb response

type OperationLock

type OperationLock struct {
	LockReason string `json:"LockReason" xml:"LockReason"`
	LockType   string `json:"LockType" xml:"LockType"`
}

OperationLock is a nested struct in nlb response

type OperationLocksInGetLoadBalancerAttribute

type OperationLocksInGetLoadBalancerAttribute struct {
	OperationLock []OperationLock `json:"OperationLock" xml:"OperationLock"`
}

OperationLocksInGetLoadBalancerAttribute is a nested struct in nlb response

type OperationLocksInListLoadBalancers

type OperationLocksInListLoadBalancers struct {
	OperationLock []OperationLock `json:"OperationLock" xml:"OperationLock"`
}

OperationLocksInListLoadBalancers is a nested struct in nlb response

type Reason

type Reason struct {
	ReasonCode string `json:"ReasonCode" xml:"ReasonCode"`
}

Reason is a nested struct in nlb response

type Region

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

Region is a nested struct in nlb response

type Regions

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

Regions is a nested struct in nlb response

type RelatedListener

type RelatedListener struct {
	ListenerId       string `json:"ListenerId" xml:"ListenerId"`
	ListenerPort     int64  `json:"ListenerPort" xml:"ListenerPort"`
	ListenerProtocol string `json:"ListenerProtocol" xml:"ListenerProtocol"`
	LoadBalancerId   string `json:"LoadBalancerId" xml:"LoadBalancerId"`
}

RelatedListener is a nested struct in nlb response

type RelatedListeners

type RelatedListeners struct {
	RelatedListener []RelatedListener `json:"RelatedListener" xml:"RelatedListener"`
}

RelatedListeners is a nested struct in nlb response

type RelatedLoadBalancerIds

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

RelatedLoadBalancerIds is a nested struct in nlb response

type RemoveServersFromServerGroupRequest

type RemoveServersFromServerGroupRequest struct {
	*requests.RpcRequest
	ClientToken   string                                 `position:"Body" name:"ClientToken"`
	ServerGroupId string                                 `position:"Body" name:"ServerGroupId"`
	Servers       *[]RemoveServersFromServerGroupServers `position:"Body" name:"Servers"  type:"Repeated"`
	DryRun        requests.Boolean                       `position:"Body" name:"DryRun"`
}

RemoveServersFromServerGroupRequest is the request struct for api RemoveServersFromServerGroup

func CreateRemoveServersFromServerGroupRequest

func CreateRemoveServersFromServerGroupRequest() (request *RemoveServersFromServerGroupRequest)

CreateRemoveServersFromServerGroupRequest creates a request to invoke RemoveServersFromServerGroup API

type RemoveServersFromServerGroupResponse

type RemoveServersFromServerGroupResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ServerGroupId  string `json:"ServerGroupId" xml:"ServerGroupId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

RemoveServersFromServerGroupResponse is the response struct for api RemoveServersFromServerGroup

func CreateRemoveServersFromServerGroupResponse

func CreateRemoveServersFromServerGroupResponse() (response *RemoveServersFromServerGroupResponse)

CreateRemoveServersFromServerGroupResponse creates a response to parse from RemoveServersFromServerGroup response

type RemoveServersFromServerGroupServers

type RemoveServersFromServerGroupServers struct {
	ServerId   string `name:"ServerId"`
	ServerType string `name:"ServerType"`
	ServerIp   string `name:"ServerIp"`
	Port       string `name:"Port"`
}

RemoveServersFromServerGroupServers is a repeated param struct in RemoveServersFromServerGroupRequest

type SecurityGroupIdsInGetLoadBalancerAttribute

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

SecurityGroupIdsInGetLoadBalancerAttribute is a nested struct in nlb response

type SecurityGroupIdsInListLoadBalancers

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

SecurityGroupIdsInListLoadBalancers is a nested struct in nlb response

type SecurityPolicie

type SecurityPolicie struct {
	RegionId             string            `json:"RegionId" xml:"RegionId"`
	ResourceGroupId      string            `json:"ResourceGroupId" xml:"ResourceGroupId"`
	Ciphers              string            `json:"Ciphers" xml:"Ciphers"`
	SecurityPolicyId     string            `json:"SecurityPolicyId" xml:"SecurityPolicyId"`
	SecurityPolicyName   string            `json:"SecurityPolicyName" xml:"SecurityPolicyName"`
	SecurityPolicyStatus string            `json:"SecurityPolicyStatus" xml:"SecurityPolicyStatus"`
	TlsVersion           string            `json:"TlsVersion" xml:"TlsVersion"`
	RelatedListeners     []RelatedListener `json:"RelatedListeners" xml:"RelatedListeners"`
	Tags                 []Tag             `json:"Tags" xml:"Tags"`
}

SecurityPolicie is a nested struct in nlb response

type SecurityPoliciesInListSecurityPolicy

type SecurityPoliciesInListSecurityPolicy struct {
	SecurityPolicie []SecurityPolicie `json:"SecurityPolicie" xml:"SecurityPolicie"`
}

SecurityPoliciesInListSecurityPolicy is a nested struct in nlb response

type SecurityPoliciesInListSystemSecurityPolicy

type SecurityPoliciesInListSystemSecurityPolicy struct {
	SecurityPolicie []SecurityPolicie `json:"SecurityPolicie" xml:"SecurityPolicie"`
}

SecurityPoliciesInListSystemSecurityPolicy is a nested struct in nlb response

type Server

type Server struct {
	ServerId      string `json:"ServerId" xml:"ServerId"`
	ServerType    string `json:"ServerType" xml:"ServerType"`
	ServerIp      string `json:"ServerIp" xml:"ServerIp"`
	Port          int    `json:"Port" xml:"Port"`
	Weight        int    `json:"Weight" xml:"Weight"`
	ServerGroupId string `json:"ServerGroupId" xml:"ServerGroupId"`
	Description   string `json:"Description" xml:"Description"`
	ZoneId        string `json:"ZoneId" xml:"ZoneId"`
	Status        string `json:"Status" xml:"Status"`
}

Server is a nested struct in nlb response

type ServerGroup

type ServerGroup struct {
	RegionId                string      `json:"RegionId" xml:"RegionId"`
	ServerGroupId           string      `json:"ServerGroupId" xml:"ServerGroupId"`
	ServerGroupName         string      `json:"ServerGroupName" xml:"ServerGroupName"`
	ServerGroupType         string      `json:"ServerGroupType" xml:"ServerGroupType"`
	AddressIPVersion        string      `json:"AddressIPVersion" xml:"AddressIPVersion"`
	VpcId                   string      `json:"VpcId" xml:"VpcId"`
	Scheduler               string      `json:"Scheduler" xml:"Scheduler"`
	Protocol                string      `json:"Protocol" xml:"Protocol"`
	PersistenceEnabled      bool        `json:"PersistenceEnabled" xml:"PersistenceEnabled"`
	PersistenceTimeout      int         `json:"PersistenceTimeout" xml:"PersistenceTimeout"`
	ConnectionDrainEnabled  bool        `json:"ConnectionDrainEnabled" xml:"ConnectionDrainEnabled"`
	ConnectionDrainTimeout  int         `json:"ConnectionDrainTimeout" xml:"ConnectionDrainTimeout"`
	PreserveClientIpEnabled bool        `json:"PreserveClientIpEnabled" xml:"PreserveClientIpEnabled"`
	AnyPortEnabled          bool        `json:"AnyPortEnabled" xml:"AnyPortEnabled"`
	ResourceGroupId         string      `json:"ResourceGroupId" xml:"ResourceGroupId"`
	ServerGroupStatus       string      `json:"ServerGroupStatus" xml:"ServerGroupStatus"`
	AliUid                  int64       `json:"AliUid" xml:"AliUid"`
	ServerCount             int         `json:"ServerCount" xml:"ServerCount"`
	RelatedLoadBalancerIds  []string    `json:"RelatedLoadBalancerIds" xml:"RelatedLoadBalancerIds"`
	HealthCheck             HealthCheck `json:"HealthCheck" xml:"HealthCheck"`
	Tags                    []Tag       `json:"Tags" xml:"Tags"`
}

ServerGroup is a nested struct in nlb response

type ServerGroupInfo

type ServerGroupInfo struct {
	HeathCheckEnabled bool             `json:"HeathCheckEnabled" xml:"HeathCheckEnabled"`
	ServerGroupId     string           `json:"ServerGroupId" xml:"ServerGroupId"`
	NonNormalServers  []AbnormalServer `json:"NonNormalServers" xml:"NonNormalServers"`
}

ServerGroupInfo is a nested struct in nlb response

type ServerGroupInfos

type ServerGroupInfos struct {
	ServerGroupInfo []ServerGroupInfo `json:"ServerGroupInfo" xml:"ServerGroupInfo"`
}

ServerGroupInfos is a nested struct in nlb response

type ServerGroups

type ServerGroups struct {
	ServerGroup []ServerGroup `json:"ServerGroup" xml:"ServerGroup"`
}

ServerGroups is a nested struct in nlb response

type Servers

type Servers struct {
	Server []Server `json:"Server" xml:"Server"`
}

Servers is a nested struct in nlb response

type StartListenerRequest

type StartListenerRequest struct {
	*requests.RpcRequest
	ClientToken string           `position:"Body" name:"ClientToken"`
	ListenerId  string           `position:"Body" name:"ListenerId"`
	DryRun      requests.Boolean `position:"Body" name:"DryRun"`
}

StartListenerRequest is the request struct for api StartListener

func CreateStartListenerRequest

func CreateStartListenerRequest() (request *StartListenerRequest)

CreateStartListenerRequest creates a request to invoke StartListener API

type StartListenerResponse

type StartListenerResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

StartListenerResponse is the response struct for api StartListener

func CreateStartListenerResponse

func CreateStartListenerResponse() (response *StartListenerResponse)

CreateStartListenerResponse creates a response to parse from StartListener response

type StopListenerRequest

type StopListenerRequest struct {
	*requests.RpcRequest
	ClientToken string           `position:"Body" name:"ClientToken"`
	ListenerId  string           `position:"Body" name:"ListenerId"`
	DryRun      requests.Boolean `position:"Body" name:"DryRun"`
}

StopListenerRequest is the request struct for api StopListener

func CreateStopListenerRequest

func CreateStopListenerRequest() (request *StopListenerRequest)

CreateStopListenerRequest creates a request to invoke StopListener API

type StopListenerResponse

type StopListenerResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

StopListenerResponse is the response struct for api StopListener

func CreateStopListenerResponse

func CreateStopListenerResponse() (response *StopListenerResponse)

CreateStopListenerResponse creates a response to parse from StopListener response

type Tag

type Tag struct {
	Key   string `json:"Key" xml:"Key"`
	Value string `json:"Value" xml:"Value"`
}

Tag is a nested struct in nlb response

type TagModels

type TagModels struct {
	Key   string `json:"Key" xml:"Key"`
	Value string `json:"Value" xml:"Value"`
}

TagModels is a nested struct in nlb response

type TagResources

type TagResources struct {
	TagResultModelList []TagResultModelList `json:"TagResultModelList" xml:"TagResultModelList"`
}

TagResources is a nested struct in nlb response

type TagResourcesRequest

type TagResourcesRequest struct {
	*requests.RpcRequest
	ClientToken  string             `position:"Body" name:"ClientToken"`
	Tag          *[]TagResourcesTag `position:"Body" name:"Tag"  type:"Repeated"`
	ResourceId   *[]string          `position:"Body" name:"ResourceId"  type:"Repeated"`
	DryRun       requests.Boolean   `position:"Body" name:"DryRun"`
	ResourceType string             `position:"Body" name:"ResourceType"`
}

TagResourcesRequest is the request struct for api TagResources

func CreateTagResourcesRequest

func CreateTagResourcesRequest() (request *TagResourcesRequest)

CreateTagResourcesRequest creates a request to invoke TagResources API

type TagResourcesResponse

type TagResourcesResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

TagResourcesResponse is the response struct for api TagResources

func CreateTagResourcesResponse

func CreateTagResourcesResponse() (response *TagResourcesResponse)

CreateTagResourcesResponse creates a response to parse from TagResources response

type TagResourcesTag

type TagResourcesTag struct {
	Key   string `name:"Key"`
	Value string `name:"Value"`
}

TagResourcesTag is a repeated param struct in TagResourcesRequest

type TagResultModelList

type TagResultModelList struct {
	ResourceId   string `json:"ResourceId" xml:"ResourceId"`
	ResourceType string `json:"ResourceType" xml:"ResourceType"`
	RegionNo     string `json:"RegionNo" xml:"RegionNo"`
	AliUid       int64  `json:"AliUid" xml:"AliUid"`
	TagKey       string `json:"TagKey" xml:"TagKey"`
	TagValue     string `json:"TagValue" xml:"TagValue"`
	Scope        string `json:"Scope" xml:"Scope"`
	Category     string `json:"Category" xml:"Category"`
}

TagResultModelList is a nested struct in nlb response

type TagsInListLoadBalancers

type TagsInListLoadBalancers struct {
	TagModels []TagModels `json:"tagModels" xml:"tagModels"`
}

TagsInListLoadBalancers is a nested struct in nlb response

type TagsInListSecurityPolicy

type TagsInListSecurityPolicy struct {
	Tag []Tag `json:"Tag" xml:"Tag"`
}

TagsInListSecurityPolicy is a nested struct in nlb response

type TagsInListServerGroups

type TagsInListServerGroups struct {
	Tag []Tag `json:"Tag" xml:"Tag"`
}

TagsInListServerGroups is a nested struct in nlb response

type UntagResourcesRequest

type UntagResourcesRequest struct {
	*requests.RpcRequest
	ClientToken  string           `position:"Body" name:"ClientToken"`
	All          requests.Boolean `position:"Body" name:"All"`
	ResourceId   *[]string        `position:"Body" name:"ResourceId"  type:"Repeated"`
	DryRun       requests.Boolean `position:"Body" name:"DryRun"`
	ResourceType string           `position:"Body" name:"ResourceType"`
	TagKey       *[]string        `position:"Body" name:"TagKey"  type:"Repeated"`
}

UntagResourcesRequest is the request struct for api UntagResources

func CreateUntagResourcesRequest

func CreateUntagResourcesRequest() (request *UntagResourcesRequest)

CreateUntagResourcesRequest creates a request to invoke UntagResources API

type UntagResourcesResponse

type UntagResourcesResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UntagResourcesResponse is the response struct for api UntagResources

func CreateUntagResourcesResponse

func CreateUntagResourcesResponse() (response *UntagResourcesResponse)

CreateUntagResourcesResponse creates a response to parse from UntagResources response

type UpdateListenerAttributeRequest

type UpdateListenerAttributeRequest struct {
	*requests.RpcRequest
	CaCertificateIds     *[]string        `position:"Body" name:"CaCertificateIds"  type:"Repeated"`
	ClientToken          string           `position:"Body" name:"ClientToken"`
	SecSensorEnabled     requests.Boolean `position:"Body" name:"SecSensorEnabled"`
	AlpnPolicy           string           `position:"Body" name:"AlpnPolicy"`
	Mss                  requests.Integer `position:"Body" name:"Mss"`
	ServerGroupId        string           `position:"Body" name:"ServerGroupId"`
	ListenerId           string           `position:"Body" name:"ListenerId"`
	CertificateIds       *[]string        `position:"Body" name:"CertificateIds"  type:"Repeated"`
	AlpnEnabled          requests.Boolean `position:"Body" name:"AlpnEnabled"`
	DryRun               requests.Boolean `position:"Body" name:"DryRun"`
	ProxyProtocolEnabled requests.Boolean `position:"Body" name:"ProxyProtocolEnabled"`
	Cps                  requests.Integer `position:"Body" name:"Cps"`
	SecurityPolicyId     string           `position:"Body" name:"SecurityPolicyId"`
	IdleTimeout          requests.Integer `position:"Body" name:"IdleTimeout"`
	ListenerDescription  string           `position:"Body" name:"ListenerDescription"`
	CaEnabled            requests.Boolean `position:"Body" name:"CaEnabled"`
}

UpdateListenerAttributeRequest is the request struct for api UpdateListenerAttribute

func CreateUpdateListenerAttributeRequest

func CreateUpdateListenerAttributeRequest() (request *UpdateListenerAttributeRequest)

CreateUpdateListenerAttributeRequest creates a request to invoke UpdateListenerAttribute API

type UpdateListenerAttributeResponse

type UpdateListenerAttributeResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UpdateListenerAttributeResponse is the response struct for api UpdateListenerAttribute

func CreateUpdateListenerAttributeResponse

func CreateUpdateListenerAttributeResponse() (response *UpdateListenerAttributeResponse)

CreateUpdateListenerAttributeResponse creates a response to parse from UpdateListenerAttribute response

type UpdateLoadBalancerAddressTypeConfigRequest

type UpdateLoadBalancerAddressTypeConfigRequest struct {
	*requests.RpcRequest
	ClientToken    string                                             `position:"Body" name:"ClientToken"`
	AddressType    string                                             `position:"Body" name:"AddressType"`
	DryRun         requests.Boolean                                   `position:"Body" name:"DryRun"`
	ZoneMappings   *[]UpdateLoadBalancerAddressTypeConfigZoneMappings `position:"Body" name:"ZoneMappings"  type:"Repeated"`
	LoadBalancerId string                                             `position:"Body" name:"LoadBalancerId"`
}

UpdateLoadBalancerAddressTypeConfigRequest is the request struct for api UpdateLoadBalancerAddressTypeConfig

func CreateUpdateLoadBalancerAddressTypeConfigRequest

func CreateUpdateLoadBalancerAddressTypeConfigRequest() (request *UpdateLoadBalancerAddressTypeConfigRequest)

CreateUpdateLoadBalancerAddressTypeConfigRequest creates a request to invoke UpdateLoadBalancerAddressTypeConfig API

type UpdateLoadBalancerAddressTypeConfigResponse

type UpdateLoadBalancerAddressTypeConfigResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UpdateLoadBalancerAddressTypeConfigResponse is the response struct for api UpdateLoadBalancerAddressTypeConfig

func CreateUpdateLoadBalancerAddressTypeConfigResponse

func CreateUpdateLoadBalancerAddressTypeConfigResponse() (response *UpdateLoadBalancerAddressTypeConfigResponse)

CreateUpdateLoadBalancerAddressTypeConfigResponse creates a response to parse from UpdateLoadBalancerAddressTypeConfig response

type UpdateLoadBalancerAddressTypeConfigZoneMappings

type UpdateLoadBalancerAddressTypeConfigZoneMappings struct {
	VSwitchId    string `name:"VSwitchId"`
	ZoneId       string `name:"ZoneId"`
	AllocationId string `name:"AllocationId"`
	EipType      string `name:"EipType"`
}

UpdateLoadBalancerAddressTypeConfigZoneMappings is a repeated param struct in UpdateLoadBalancerAddressTypeConfigRequest

type UpdateLoadBalancerAttributeRequest

type UpdateLoadBalancerAttributeRequest struct {
	*requests.RpcRequest
	CrossZoneEnabled       requests.Boolean `position:"Body" name:"CrossZoneEnabled"`
	ClientToken            string           `position:"Body" name:"ClientToken"`
	LoadBalancerName       string           `position:"Body" name:"LoadBalancerName"`
	DryRun                 requests.Boolean `position:"Body" name:"DryRun"`
	Cps                    requests.Integer `position:"Body" name:"Cps"`
	TrafficAffinityEnabled requests.Boolean `position:"Body" name:"TrafficAffinityEnabled"`
	SecurityGroupIds       *[]string        `position:"Body" name:"SecurityGroupIds"  type:"Repeated"`
	LoadBalancerId         string           `position:"Body" name:"LoadBalancerId"`
}

UpdateLoadBalancerAttributeRequest is the request struct for api UpdateLoadBalancerAttribute

func CreateUpdateLoadBalancerAttributeRequest

func CreateUpdateLoadBalancerAttributeRequest() (request *UpdateLoadBalancerAttributeRequest)

CreateUpdateLoadBalancerAttributeRequest creates a request to invoke UpdateLoadBalancerAttribute API

type UpdateLoadBalancerAttributeResponse

type UpdateLoadBalancerAttributeResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UpdateLoadBalancerAttributeResponse is the response struct for api UpdateLoadBalancerAttribute

func CreateUpdateLoadBalancerAttributeResponse

func CreateUpdateLoadBalancerAttributeResponse() (response *UpdateLoadBalancerAttributeResponse)

CreateUpdateLoadBalancerAttributeResponse creates a response to parse from UpdateLoadBalancerAttribute response

type UpdateLoadBalancerProtectionRequest

type UpdateLoadBalancerProtectionRequest struct {
	*requests.RpcRequest
	DeletionProtectionReason     string           `position:"Body" name:"DeletionProtectionReason"`
	ModificationProtectionReason string           `position:"Body" name:"ModificationProtectionReason"`
	ClientToken                  string           `position:"Body" name:"ClientToken"`
	DeletionProtectionEnabled    requests.Boolean `position:"Body" name:"DeletionProtectionEnabled"`
	DryRun                       requests.Boolean `position:"Body" name:"DryRun"`
	ModificationProtectionStatus string           `position:"Body" name:"ModificationProtectionStatus"`
	LoadBalancerId               string           `position:"Body" name:"LoadBalancerId"`
}

UpdateLoadBalancerProtectionRequest is the request struct for api UpdateLoadBalancerProtection

func CreateUpdateLoadBalancerProtectionRequest

func CreateUpdateLoadBalancerProtectionRequest() (request *UpdateLoadBalancerProtectionRequest)

CreateUpdateLoadBalancerProtectionRequest creates a request to invoke UpdateLoadBalancerProtection API

type UpdateLoadBalancerProtectionResponse

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

UpdateLoadBalancerProtectionResponse is the response struct for api UpdateLoadBalancerProtection

func CreateUpdateLoadBalancerProtectionResponse

func CreateUpdateLoadBalancerProtectionResponse() (response *UpdateLoadBalancerProtectionResponse)

CreateUpdateLoadBalancerProtectionResponse creates a response to parse from UpdateLoadBalancerProtection response

type UpdateLoadBalancerZonesRequest

type UpdateLoadBalancerZonesRequest struct {
	*requests.RpcRequest
	ClientToken    string                                 `position:"Body" name:"ClientToken"`
	DryRun         requests.Boolean                       `position:"Body" name:"DryRun"`
	ZoneMappings   *[]UpdateLoadBalancerZonesZoneMappings `position:"Body" name:"ZoneMappings"  type:"Repeated"`
	LoadBalancerId string                                 `position:"Body" name:"LoadBalancerId"`
}

UpdateLoadBalancerZonesRequest is the request struct for api UpdateLoadBalancerZones

func CreateUpdateLoadBalancerZonesRequest

func CreateUpdateLoadBalancerZonesRequest() (request *UpdateLoadBalancerZonesRequest)

CreateUpdateLoadBalancerZonesRequest creates a request to invoke UpdateLoadBalancerZones API

type UpdateLoadBalancerZonesResponse

type UpdateLoadBalancerZonesResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UpdateLoadBalancerZonesResponse is the response struct for api UpdateLoadBalancerZones

func CreateUpdateLoadBalancerZonesResponse

func CreateUpdateLoadBalancerZonesResponse() (response *UpdateLoadBalancerZonesResponse)

CreateUpdateLoadBalancerZonesResponse creates a response to parse from UpdateLoadBalancerZones response

type UpdateLoadBalancerZonesZoneMappings

type UpdateLoadBalancerZonesZoneMappings struct {
	VSwitchId          string `name:"VSwitchId"`
	ZoneId             string `name:"ZoneId"`
	PrivateIPv4Address string `name:"PrivateIPv4Address"`
	AllocationId       string `name:"AllocationId"`
	EipType            string `name:"EipType"`
}

UpdateLoadBalancerZonesZoneMappings is a repeated param struct in UpdateLoadBalancerZonesRequest

type UpdateSecurityPolicyAttributeRequest

type UpdateSecurityPolicyAttributeRequest struct {
	*requests.RpcRequest
	ClientToken        string           `position:"Body" name:"ClientToken"`
	Ciphers            *[]string        `position:"Body" name:"Ciphers"  type:"Repeated"`
	TlsVersions        *[]string        `position:"Body" name:"TlsVersions"  type:"Repeated"`
	SecurityPolicyName string           `position:"Body" name:"SecurityPolicyName"`
	DryRun             requests.Boolean `position:"Body" name:"DryRun"`
	SecurityPolicyId   string           `position:"Body" name:"SecurityPolicyId"`
}

UpdateSecurityPolicyAttributeRequest is the request struct for api UpdateSecurityPolicyAttribute

func CreateUpdateSecurityPolicyAttributeRequest

func CreateUpdateSecurityPolicyAttributeRequest() (request *UpdateSecurityPolicyAttributeRequest)

CreateUpdateSecurityPolicyAttributeRequest creates a request to invoke UpdateSecurityPolicyAttribute API

type UpdateSecurityPolicyAttributeResponse

type UpdateSecurityPolicyAttributeResponse struct {
	*responses.BaseResponse
	RequestId        string `json:"RequestId" xml:"RequestId"`
	Success          bool   `json:"Success" xml:"Success"`
	Code             string `json:"Code" xml:"Code"`
	Message          string `json:"Message" xml:"Message"`
	HttpStatusCode   int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode      string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage   string `json:"DynamicMessage" xml:"DynamicMessage"`
	SecurityPolicyId string `json:"SecurityPolicyId" xml:"SecurityPolicyId"`
	JobId            string `json:"JobId" xml:"JobId"`
}

UpdateSecurityPolicyAttributeResponse is the response struct for api UpdateSecurityPolicyAttribute

func CreateUpdateSecurityPolicyAttributeResponse

func CreateUpdateSecurityPolicyAttributeResponse() (response *UpdateSecurityPolicyAttributeResponse)

CreateUpdateSecurityPolicyAttributeResponse creates a response to parse from UpdateSecurityPolicyAttribute response

type UpdateServerGroupAttributeHealthCheckConfig

type UpdateServerGroupAttributeHealthCheckConfig struct {
	HealthCheckEnabled        string    `name:"HealthCheckEnabled"`
	HealthCheckType           string    `name:"HealthCheckType"`
	HealthCheckConnectPort    string    `name:"HealthCheckConnectPort"`
	HealthyThreshold          string    `name:"HealthyThreshold"`
	UnhealthyThreshold        string    `name:"UnhealthyThreshold"`
	HealthCheckConnectTimeout string    `name:"HealthCheckConnectTimeout"`
	HealthCheckInterval       string    `name:"HealthCheckInterval"`
	HealthCheckDomain         string    `name:"HealthCheckDomain"`
	HealthCheckUrl            string    `name:"HealthCheckUrl"`
	HealthCheckHttpCode       *[]string `name:"HealthCheckHttpCode" type:"Repeated"`
	HttpCheckMethod           string    `name:"HttpCheckMethod"`
}

UpdateServerGroupAttributeHealthCheckConfig is a repeated param struct in UpdateServerGroupAttributeRequest

type UpdateServerGroupAttributeRequest

type UpdateServerGroupAttributeRequest struct {
	*requests.RpcRequest
	ServerGroupName         string                                      `position:"Body" name:"ServerGroupName"`
	ClientToken             string                                      `position:"Body" name:"ClientToken"`
	PreserveClientIpEnabled requests.Boolean                            `position:"Body" name:"PreserveClientIpEnabled"`
	HealthCheckConfig       UpdateServerGroupAttributeHealthCheckConfig `position:"Body" name:"HealthCheckConfig"  type:"Struct"`
	ServerGroupId           string                                      `position:"Body" name:"ServerGroupId"`
	Scheduler               string                                      `position:"Body" name:"Scheduler"`
	PersistenceEnabled      requests.Boolean                            `position:"Body" name:"PersistenceEnabled"`
	PersistenceTimeout      requests.Integer                            `position:"Body" name:"PersistenceTimeout"`
	DryRun                  requests.Boolean                            `position:"Body" name:"DryRun"`
	ConnectionDrainEnabled  requests.Boolean                            `position:"Body" name:"ConnectionDrainEnabled"`
	ConnectionDrainTimeout  requests.Integer                            `position:"Body" name:"ConnectionDrainTimeout"`
}

UpdateServerGroupAttributeRequest is the request struct for api UpdateServerGroupAttribute

func CreateUpdateServerGroupAttributeRequest

func CreateUpdateServerGroupAttributeRequest() (request *UpdateServerGroupAttributeRequest)

CreateUpdateServerGroupAttributeRequest creates a request to invoke UpdateServerGroupAttribute API

type UpdateServerGroupAttributeResponse

type UpdateServerGroupAttributeResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ServerGroupId  string `json:"ServerGroupId" xml:"ServerGroupId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UpdateServerGroupAttributeResponse is the response struct for api UpdateServerGroupAttribute

func CreateUpdateServerGroupAttributeResponse

func CreateUpdateServerGroupAttributeResponse() (response *UpdateServerGroupAttributeResponse)

CreateUpdateServerGroupAttributeResponse creates a response to parse from UpdateServerGroupAttribute response

type UpdateServerGroupServersAttributeRequest

type UpdateServerGroupServersAttributeRequest struct {
	*requests.RpcRequest
	ClientToken   string                                      `position:"Body" name:"ClientToken"`
	ServerGroupId string                                      `position:"Body" name:"ServerGroupId"`
	Servers       *[]UpdateServerGroupServersAttributeServers `position:"Body" name:"Servers"  type:"Repeated"`
	DryRun        requests.Boolean                            `position:"Body" name:"DryRun"`
}

UpdateServerGroupServersAttributeRequest is the request struct for api UpdateServerGroupServersAttribute

func CreateUpdateServerGroupServersAttributeRequest

func CreateUpdateServerGroupServersAttributeRequest() (request *UpdateServerGroupServersAttributeRequest)

CreateUpdateServerGroupServersAttributeRequest creates a request to invoke UpdateServerGroupServersAttribute API

type UpdateServerGroupServersAttributeResponse

type UpdateServerGroupServersAttributeResponse struct {
	*responses.BaseResponse
	RequestId      string `json:"RequestId" xml:"RequestId"`
	Success        bool   `json:"Success" xml:"Success"`
	Code           string `json:"Code" xml:"Code"`
	Message        string `json:"Message" xml:"Message"`
	HttpStatusCode int    `json:"HttpStatusCode" xml:"HttpStatusCode"`
	DynamicCode    string `json:"DynamicCode" xml:"DynamicCode"`
	DynamicMessage string `json:"DynamicMessage" xml:"DynamicMessage"`
	ServerGroupId  string `json:"ServerGroupId" xml:"ServerGroupId"`
	JobId          string `json:"JobId" xml:"JobId"`
}

UpdateServerGroupServersAttributeResponse is the response struct for api UpdateServerGroupServersAttribute

func CreateUpdateServerGroupServersAttributeResponse

func CreateUpdateServerGroupServersAttributeResponse() (response *UpdateServerGroupServersAttributeResponse)

CreateUpdateServerGroupServersAttributeResponse creates a response to parse from UpdateServerGroupServersAttribute response

type UpdateServerGroupServersAttributeServers

type UpdateServerGroupServersAttributeServers struct {
	ServerId    string `name:"ServerId"`
	ServerType  string `name:"ServerType"`
	ServerIp    string `name:"ServerIp"`
	Port        string `name:"Port"`
	Weight      string `name:"Weight"`
	Description string `name:"Description"`
}

UpdateServerGroupServersAttributeServers is a repeated param struct in UpdateServerGroupServersAttributeRequest

type Zone

type Zone struct {
	LocalName string `json:"LocalName" xml:"LocalName"`
	ZoneId    string `json:"ZoneId" xml:"ZoneId"`
}

Zone is a nested struct in nlb response

type ZoneMapping

type ZoneMapping struct {
	ZoneId                string                `json:"ZoneId" xml:"ZoneId"`
	VSwitchId             string                `json:"VSwitchId" xml:"VSwitchId"`
	EipType               string                `json:"EipType" xml:"EipType"`
	LoadBalancerAddresses []LoadBalancerAddress `json:"LoadBalancerAddresses" xml:"LoadBalancerAddresses"`
}

ZoneMapping is a nested struct in nlb response

type ZoneMappingsInGetLoadBalancerAttribute

type ZoneMappingsInGetLoadBalancerAttribute struct {
	ZoneMapping []ZoneMapping `json:"ZoneMapping" xml:"ZoneMapping"`
}

ZoneMappingsInGetLoadBalancerAttribute is a nested struct in nlb response

type ZoneMappingsInListLoadBalancers

type ZoneMappingsInListLoadBalancers struct {
	ZoneMapping []ZoneMapping `json:"ZoneMapping" xml:"ZoneMapping"`
}

ZoneMappingsInListLoadBalancers is a nested struct in nlb response

type Zones

type Zones struct {
	Zone []Zone `json:"Zone" xml:"Zone"`
}

Zones is a nested struct in nlb response