ecd

package
v0.2.0 Latest Latest
Warning

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

Go to latest
Published: Jan 25, 2023 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

View Source
var EndpointMap map[string]string

EndpointMap Endpoint Data

View Source
var EndpointType = "regional"

EndpointType regional or central

Functions ¶

func GetEndpointMap ¶

func GetEndpointMap() map[string]string

GetEndpointMap Get Endpoint Data Map

func GetEndpointType ¶

func GetEndpointType() string

GetEndpointType Get Endpoint Type Value

func SetClientProperty ¶

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

SetClientProperty Set Property by Reflect

func SetEndpointDataToClient ¶

func SetEndpointDataToClient(client *Client)

SetEndpointDataToClient Set EndpointMap and ENdpointType

Types ¶

type ADConnector ¶

type ADConnector struct {
	VSwitchId          string `json:"VSwitchId" xml:"VSwitchId"`
	ADConnectorAddress string `json:"ADConnectorAddress" xml:"ADConnectorAddress"`
	NetworkInterfaceId string `json:"NetworkInterfaceId" xml:"NetworkInterfaceId"`
	TrustKey           string `json:"TrustKey" xml:"TrustKey"`
	ConnectorStatus    string `json:"ConnectorStatus" xml:"ConnectorStatus"`
	Specification      string `json:"Specification" xml:"Specification"`
}

ADConnector is a nested struct in ecd response

type ADConnectorsInDescribeDirectories ¶

type ADConnectorsInDescribeDirectories struct {
	ADConnector []ADConnector `json:"ADConnector" xml:"ADConnector"`
}

ADConnectorsInDescribeDirectories is a nested struct in ecd response

type ADConnectorsInDescribeOfficeSites ¶

type ADConnectorsInDescribeOfficeSites struct {
	ADConnector []ADConnector `json:"ADConnector" xml:"ADConnector"`
}

ADConnectorsInDescribeOfficeSites is a nested struct in ecd response

type ActivateOfficeSiteRequest ¶

type ActivateOfficeSiteRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
}

ActivateOfficeSiteRequest is the request struct for api ActivateOfficeSite

func CreateActivateOfficeSiteRequest ¶

func CreateActivateOfficeSiteRequest() (request *ActivateOfficeSiteRequest)

CreateActivateOfficeSiteRequest creates a request to invoke ActivateOfficeSite API

type ActivateOfficeSiteResponse ¶

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

ActivateOfficeSiteResponse is the response struct for api ActivateOfficeSite

func CreateActivateOfficeSiteResponse ¶

func CreateActivateOfficeSiteResponse() (response *ActivateOfficeSiteResponse)

CreateActivateOfficeSiteResponse creates a response to parse from ActivateOfficeSite response

type AdConnector ¶

type AdConnector struct {
	Address string `json:"Address" xml:"Address"`
}

AdConnector is a nested struct in ecd response

type AdConnectors ¶

type AdConnectors struct {
	AdConnector []AdConnector `json:"AdConnector" xml:"AdConnector"`
}

AdConnectors is a nested struct in ecd response

type AddUserToDesktopGroupRequest ¶

type AddUserToDesktopGroupRequest struct {
	*requests.RpcRequest
	EndUserIds      *[]string `position:"Query" name:"EndUserIds"  type:"Repeated"`
	ClientToken     string    `position:"Query" name:"ClientToken"`
	DesktopGroupId  string    `position:"Query" name:"DesktopGroupId"`
	DesktopGroupIds *[]string `position:"Query" name:"DesktopGroupIds"  type:"Repeated"`
}

AddUserToDesktopGroupRequest is the request struct for api AddUserToDesktopGroup

func CreateAddUserToDesktopGroupRequest ¶

func CreateAddUserToDesktopGroupRequest() (request *AddUserToDesktopGroupRequest)

CreateAddUserToDesktopGroupRequest creates a request to invoke AddUserToDesktopGroup API

type AddUserToDesktopGroupResponse ¶

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

AddUserToDesktopGroupResponse is the response struct for api AddUserToDesktopGroup

func CreateAddUserToDesktopGroupResponse ¶

func CreateAddUserToDesktopGroupResponse() (response *AddUserToDesktopGroupResponse)

CreateAddUserToDesktopGroupResponse creates a response to parse from AddUserToDesktopGroup response

type AliUids ¶

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

AliUids is a nested struct in ecd response

type AllowDiskSize ¶

type AllowDiskSize struct {
	AllowDiskSizeItem []AllowDiskSizeItem `json:"AllowDiskSize" xml:"AllowDiskSize"`
}

AllowDiskSize is a nested struct in ecd response

type AllowDiskSizeItem ¶

type AllowDiskSizeItem struct {
	DataDiskSize        int `json:"DataDiskSize" xml:"DataDiskSize"`
	SystemDiskSize      int `json:"SystemDiskSize" xml:"SystemDiskSize"`
	DefaultDataDiskSize int `json:"DefaultDataDiskSize" xml:"DefaultDataDiskSize"`
}

AllowDiskSizeItem is a nested struct in ecd response

type ApplyCoordinationForMonitoringRequest ¶

type ApplyCoordinationForMonitoringRequest struct {
	*requests.RpcRequest
	Uuid                 string                                              `position:"Query" name:"Uuid"`
	InitiatorType        string                                              `position:"Query" name:"InitiatorType"`
	CoordinatePolicyType string                                              `position:"Query" name:"CoordinatePolicyType"`
	ResourceCandidates   *[]ApplyCoordinationForMonitoringResourceCandidates `position:"Query" name:"ResourceCandidates"  type:"Repeated"`
	EndUserId            string                                              `position:"Query" name:"EndUserId"`
}

ApplyCoordinationForMonitoringRequest is the request struct for api ApplyCoordinationForMonitoring

func CreateApplyCoordinationForMonitoringRequest ¶

func CreateApplyCoordinationForMonitoringRequest() (request *ApplyCoordinationForMonitoringRequest)

CreateApplyCoordinationForMonitoringRequest creates a request to invoke ApplyCoordinationForMonitoring API

type ApplyCoordinationForMonitoringResourceCandidates ¶

type ApplyCoordinationForMonitoringResourceCandidates struct {
	ResourceId         string `name:"ResourceId"`
	ResourceProperties string `name:"ResourceProperties"`
	ResourceName       string `name:"ResourceName"`
	ResourceType       string `name:"ResourceType"`
	OwnerWyId          string `name:"OwnerWyId"`
	ResourceRegionId   string `name:"ResourceRegionId"`
	OwnerAliUid        string `name:"OwnerAliUid"`
	OwnerEndUserId     string `name:"OwnerEndUserId"`
}

ApplyCoordinationForMonitoringResourceCandidates is a repeated param struct in ApplyCoordinationForMonitoringRequest

type ApplyCoordinationForMonitoringResponse ¶

type ApplyCoordinationForMonitoringResponse struct {
	*responses.BaseResponse
	RequestId            string                `json:"RequestId" xml:"RequestId"`
	CoordinateFlowModels []CoordinateFlowModel `json:"CoordinateFlowModels" xml:"CoordinateFlowModels"`
}

ApplyCoordinationForMonitoringResponse is the response struct for api ApplyCoordinationForMonitoring

func CreateApplyCoordinationForMonitoringResponse ¶

func CreateApplyCoordinationForMonitoringResponse() (response *ApplyCoordinationForMonitoringResponse)

CreateApplyCoordinationForMonitoringResponse creates a response to parse from ApplyCoordinationForMonitoring response

type ApproveFotaUpdateRequest ¶

type ApproveFotaUpdateRequest struct {
	*requests.RpcRequest
	AppVersion string `position:"Query" name:"AppVersion"`
	DesktopId  string `position:"Query" name:"DesktopId"`
}

ApproveFotaUpdateRequest is the request struct for api ApproveFotaUpdate

func CreateApproveFotaUpdateRequest ¶

func CreateApproveFotaUpdateRequest() (request *ApproveFotaUpdateRequest)

CreateApproveFotaUpdateRequest creates a request to invoke ApproveFotaUpdate API

type ApproveFotaUpdateResponse ¶

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

ApproveFotaUpdateResponse is the response struct for api ApproveFotaUpdate

func CreateApproveFotaUpdateResponse ¶

func CreateApproveFotaUpdateResponse() (response *ApproveFotaUpdateResponse)

CreateApproveFotaUpdateResponse creates a response to parse from ApproveFotaUpdate response

type AssociateNetworkPackageRequest ¶

type AssociateNetworkPackageRequest struct {
	*requests.RpcRequest
	OfficeSiteId     string `position:"Query" name:"OfficeSiteId"`
	NetworkPackageId string `position:"Query" name:"NetworkPackageId"`
}

AssociateNetworkPackageRequest is the request struct for api AssociateNetworkPackage

func CreateAssociateNetworkPackageRequest ¶

func CreateAssociateNetworkPackageRequest() (request *AssociateNetworkPackageRequest)

CreateAssociateNetworkPackageRequest creates a request to invoke AssociateNetworkPackage API

type AssociateNetworkPackageResponse ¶

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

AssociateNetworkPackageResponse is the response struct for api AssociateNetworkPackage

func CreateAssociateNetworkPackageResponse ¶

func CreateAssociateNetworkPackageResponse() (response *AssociateNetworkPackageResponse)

CreateAssociateNetworkPackageResponse creates a response to parse from AssociateNetworkPackage response

type AttachCenRequest ¶

type AttachCenRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	CenId        string           `position:"Query" name:"CenId"`
	CenOwnerId   requests.Integer `position:"Query" name:"CenOwnerId"`
	VerifyCode   string           `position:"Query" name:"VerifyCode"`
}

AttachCenRequest is the request struct for api AttachCen

func CreateAttachCenRequest ¶

func CreateAttachCenRequest() (request *AttachCenRequest)

CreateAttachCenRequest creates a request to invoke AttachCen API

type AttachCenResponse ¶

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

AttachCenResponse is the response struct for api AttachCen

func CreateAttachCenResponse ¶

func CreateAttachCenResponse() (response *AttachCenResponse)

CreateAttachCenResponse creates a response to parse from AttachCen response

type AuthorizeAccessPolicyRule ¶

type AuthorizeAccessPolicyRule struct {
	Description string `json:"Description" xml:"Description"`
	CidrIp      string `json:"CidrIp" xml:"CidrIp"`
}

AuthorizeAccessPolicyRule is a nested struct in ecd response

type AuthorizeAccessPolicyRules ¶

type AuthorizeAccessPolicyRules struct {
	AuthorizeAccessPolicyRule []AuthorizeAccessPolicyRule `json:"AuthorizeAccessPolicyRule" xml:"AuthorizeAccessPolicyRule"`
}

AuthorizeAccessPolicyRules is a nested struct in ecd response

type AuthorizeSecurityPolicyRule ¶

type AuthorizeSecurityPolicyRule struct {
	Type        string `json:"Type" xml:"Type"`
	Policy      string `json:"Policy" xml:"Policy"`
	Description string `json:"Description" xml:"Description"`
	PortRange   string `json:"PortRange" xml:"PortRange"`
	IpProtocol  string `json:"IpProtocol" xml:"IpProtocol"`
	Priority    string `json:"Priority" xml:"Priority"`
	CidrIp      string `json:"CidrIp" xml:"CidrIp"`
}

AuthorizeSecurityPolicyRule is a nested struct in ecd response

type AuthorizeSecurityPolicyRules ¶

type AuthorizeSecurityPolicyRules struct {
	AuthorizeSecurityPolicyRule []AuthorizeSecurityPolicyRule `json:"AuthorizeSecurityPolicyRule" xml:"AuthorizeSecurityPolicyRule"`
}

AuthorizeSecurityPolicyRules is a nested struct in ecd response

type Bundle ¶

type Bundle struct {
	Description             string               `json:"Description" xml:"Description"`
	BundleType              string               `json:"BundleType" xml:"BundleType"`
	OsType                  string               `json:"OsType" xml:"OsType"`
	StockState              string               `json:"StockState" xml:"StockState"`
	DesktopType             string               `json:"DesktopType" xml:"DesktopType"`
	ProtocolType            string               `json:"ProtocolType" xml:"ProtocolType"`
	BundleId                string               `json:"BundleId" xml:"BundleId"`
	ImageId                 string               `json:"ImageId" xml:"ImageId"`
	ImageName               string               `json:"ImageName" xml:"ImageName"`
	Language                string               `json:"Language" xml:"Language"`
	BundleName              string               `json:"BundleName" xml:"BundleName"`
	DesktopTypeFamily       string               `json:"DesktopTypeFamily" xml:"DesktopTypeFamily"`
	CreationTime            string               `json:"CreationTime" xml:"CreationTime"`
	SessionType             string               `json:"SessionType" xml:"SessionType"`
	VolumeEncryptionEnabled bool                 `json:"VolumeEncryptionEnabled" xml:"VolumeEncryptionEnabled"`
	VolumeEncryptionKey     string               `json:"VolumeEncryptionKey" xml:"VolumeEncryptionKey"`
	DesktopTypeAttribute    DesktopTypeAttribute `json:"DesktopTypeAttribute" xml:"DesktopTypeAttribute"`
	Disks                   []Disk               `json:"Disks" xml:"Disks"`
}

Bundle is a nested struct in ecd response

type Bundles ¶

type Bundles struct {
	Bundle []Bundle `json:"Bundle" xml:"Bundle"`
}

Bundles is a nested struct in ecd response

type CancelCopyImageRequest ¶

type CancelCopyImageRequest struct {
	*requests.RpcRequest
	ImageId string `position:"Query" name:"ImageId"`
}

CancelCopyImageRequest is the request struct for api CancelCopyImage

func CreateCancelCopyImageRequest ¶

func CreateCancelCopyImageRequest() (request *CancelCopyImageRequest)

CreateCancelCopyImageRequest creates a request to invoke CancelCopyImage API

type CancelCopyImageResponse ¶

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

CancelCopyImageResponse is the response struct for api CancelCopyImage

func CreateCancelCopyImageResponse ¶

func CreateCancelCopyImageResponse() (response *CancelCopyImageResponse)

CreateCancelCopyImageResponse creates a response to parse from CancelCopyImage response

type Cen ¶

type Cen struct {
	Status          string      `json:"Status" xml:"Status"`
	CreationTime    string      `json:"CreationTime" xml:"CreationTime"`
	Ipv6Level       string      `json:"Ipv6Level" xml:"Ipv6Level"`
	Description     string      `json:"Description" xml:"Description"`
	CenId           string      `json:"CenId" xml:"CenId"`
	ProtectionLevel string      `json:"ProtectionLevel" xml:"ProtectionLevel"`
	Name            string      `json:"Name" xml:"Name"`
	Tags            []Tag       `json:"Tags" xml:"Tags"`
	PackageIds      []PackageId `json:"PackageIds" xml:"PackageIds"`
}

Cen is a nested struct in ecd response

type Cens ¶

type Cens struct {
	Cen []Cen `json:"Cen" xml:"Cen"`
}

Cens is a nested struct in ecd response

type CidrBlocks ¶

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

CidrBlocks is a nested struct in ecd 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) ActivateOfficeSite ¶

func (client *Client) ActivateOfficeSite(request *ActivateOfficeSiteRequest) (response *ActivateOfficeSiteResponse, err error)

ActivateOfficeSite invokes the ecd.ActivateOfficeSite API synchronously

func (*Client) ActivateOfficeSiteWithCallback ¶

func (client *Client) ActivateOfficeSiteWithCallback(request *ActivateOfficeSiteRequest, callback func(response *ActivateOfficeSiteResponse, err error)) <-chan int

ActivateOfficeSiteWithCallback invokes the ecd.ActivateOfficeSite API asynchronously

func (*Client) ActivateOfficeSiteWithChan ¶

func (client *Client) ActivateOfficeSiteWithChan(request *ActivateOfficeSiteRequest) (<-chan *ActivateOfficeSiteResponse, <-chan error)

ActivateOfficeSiteWithChan invokes the ecd.ActivateOfficeSite API asynchronously

func (*Client) AddUserToDesktopGroup ¶

func (client *Client) AddUserToDesktopGroup(request *AddUserToDesktopGroupRequest) (response *AddUserToDesktopGroupResponse, err error)

AddUserToDesktopGroup invokes the ecd.AddUserToDesktopGroup API synchronously

func (*Client) AddUserToDesktopGroupWithCallback ¶

func (client *Client) AddUserToDesktopGroupWithCallback(request *AddUserToDesktopGroupRequest, callback func(response *AddUserToDesktopGroupResponse, err error)) <-chan int

AddUserToDesktopGroupWithCallback invokes the ecd.AddUserToDesktopGroup API asynchronously

func (*Client) AddUserToDesktopGroupWithChan ¶

func (client *Client) AddUserToDesktopGroupWithChan(request *AddUserToDesktopGroupRequest) (<-chan *AddUserToDesktopGroupResponse, <-chan error)

AddUserToDesktopGroupWithChan invokes the ecd.AddUserToDesktopGroup API asynchronously

func (*Client) ApplyCoordinationForMonitoring ¶

func (client *Client) ApplyCoordinationForMonitoring(request *ApplyCoordinationForMonitoringRequest) (response *ApplyCoordinationForMonitoringResponse, err error)

ApplyCoordinationForMonitoring invokes the ecd.ApplyCoordinationForMonitoring API synchronously

func (*Client) ApplyCoordinationForMonitoringWithCallback ¶

func (client *Client) ApplyCoordinationForMonitoringWithCallback(request *ApplyCoordinationForMonitoringRequest, callback func(response *ApplyCoordinationForMonitoringResponse, err error)) <-chan int

ApplyCoordinationForMonitoringWithCallback invokes the ecd.ApplyCoordinationForMonitoring API asynchronously

func (*Client) ApplyCoordinationForMonitoringWithChan ¶

func (client *Client) ApplyCoordinationForMonitoringWithChan(request *ApplyCoordinationForMonitoringRequest) (<-chan *ApplyCoordinationForMonitoringResponse, <-chan error)

ApplyCoordinationForMonitoringWithChan invokes the ecd.ApplyCoordinationForMonitoring API asynchronously

func (*Client) ApproveFotaUpdate ¶

func (client *Client) ApproveFotaUpdate(request *ApproveFotaUpdateRequest) (response *ApproveFotaUpdateResponse, err error)

ApproveFotaUpdate invokes the ecd.ApproveFotaUpdate API synchronously

func (*Client) ApproveFotaUpdateWithCallback ¶

func (client *Client) ApproveFotaUpdateWithCallback(request *ApproveFotaUpdateRequest, callback func(response *ApproveFotaUpdateResponse, err error)) <-chan int

ApproveFotaUpdateWithCallback invokes the ecd.ApproveFotaUpdate API asynchronously

func (*Client) ApproveFotaUpdateWithChan ¶

func (client *Client) ApproveFotaUpdateWithChan(request *ApproveFotaUpdateRequest) (<-chan *ApproveFotaUpdateResponse, <-chan error)

ApproveFotaUpdateWithChan invokes the ecd.ApproveFotaUpdate API asynchronously

func (*Client) AssociateNetworkPackage ¶

func (client *Client) AssociateNetworkPackage(request *AssociateNetworkPackageRequest) (response *AssociateNetworkPackageResponse, err error)

AssociateNetworkPackage invokes the ecd.AssociateNetworkPackage API synchronously

func (*Client) AssociateNetworkPackageWithCallback ¶

func (client *Client) AssociateNetworkPackageWithCallback(request *AssociateNetworkPackageRequest, callback func(response *AssociateNetworkPackageResponse, err error)) <-chan int

AssociateNetworkPackageWithCallback invokes the ecd.AssociateNetworkPackage API asynchronously

func (*Client) AssociateNetworkPackageWithChan ¶

func (client *Client) AssociateNetworkPackageWithChan(request *AssociateNetworkPackageRequest) (<-chan *AssociateNetworkPackageResponse, <-chan error)

AssociateNetworkPackageWithChan invokes the ecd.AssociateNetworkPackage API asynchronously

func (*Client) AttachCen ¶

func (client *Client) AttachCen(request *AttachCenRequest) (response *AttachCenResponse, err error)

AttachCen invokes the ecd.AttachCen API synchronously

func (*Client) AttachCenWithCallback ¶

func (client *Client) AttachCenWithCallback(request *AttachCenRequest, callback func(response *AttachCenResponse, err error)) <-chan int

AttachCenWithCallback invokes the ecd.AttachCen API asynchronously

func (*Client) AttachCenWithChan ¶

func (client *Client) AttachCenWithChan(request *AttachCenRequest) (<-chan *AttachCenResponse, <-chan error)

AttachCenWithChan invokes the ecd.AttachCen API asynchronously

func (*Client) CancelCopyImage ¶

func (client *Client) CancelCopyImage(request *CancelCopyImageRequest) (response *CancelCopyImageResponse, err error)

CancelCopyImage invokes the ecd.CancelCopyImage API synchronously

func (*Client) CancelCopyImageWithCallback ¶

func (client *Client) CancelCopyImageWithCallback(request *CancelCopyImageRequest, callback func(response *CancelCopyImageResponse, err error)) <-chan int

CancelCopyImageWithCallback invokes the ecd.CancelCopyImage API asynchronously

func (*Client) CancelCopyImageWithChan ¶

func (client *Client) CancelCopyImageWithChan(request *CancelCopyImageRequest) (<-chan *CancelCopyImageResponse, <-chan error)

CancelCopyImageWithChan invokes the ecd.CancelCopyImage API asynchronously

func (*Client) ClonePolicyGroup ¶

func (client *Client) ClonePolicyGroup(request *ClonePolicyGroupRequest) (response *ClonePolicyGroupResponse, err error)

ClonePolicyGroup invokes the ecd.ClonePolicyGroup API synchronously

func (*Client) ClonePolicyGroupWithCallback ¶

func (client *Client) ClonePolicyGroupWithCallback(request *ClonePolicyGroupRequest, callback func(response *ClonePolicyGroupResponse, err error)) <-chan int

ClonePolicyGroupWithCallback invokes the ecd.ClonePolicyGroup API asynchronously

func (*Client) ClonePolicyGroupWithChan ¶

func (client *Client) ClonePolicyGroupWithChan(request *ClonePolicyGroupRequest) (<-chan *ClonePolicyGroupResponse, <-chan error)

ClonePolicyGroupWithChan invokes the ecd.ClonePolicyGroup API asynchronously

func (*Client) ConfigADConnectorTrust ¶

func (client *Client) ConfigADConnectorTrust(request *ConfigADConnectorTrustRequest) (response *ConfigADConnectorTrustResponse, err error)

ConfigADConnectorTrust invokes the ecd.ConfigADConnectorTrust API synchronously

func (*Client) ConfigADConnectorTrustWithCallback ¶

func (client *Client) ConfigADConnectorTrustWithCallback(request *ConfigADConnectorTrustRequest, callback func(response *ConfigADConnectorTrustResponse, err error)) <-chan int

ConfigADConnectorTrustWithCallback invokes the ecd.ConfigADConnectorTrust API asynchronously

func (*Client) ConfigADConnectorTrustWithChan ¶

func (client *Client) ConfigADConnectorTrustWithChan(request *ConfigADConnectorTrustRequest) (<-chan *ConfigADConnectorTrustResponse, <-chan error)

ConfigADConnectorTrustWithChan invokes the ecd.ConfigADConnectorTrust API asynchronously

func (*Client) ConfigADConnectorUser ¶

func (client *Client) ConfigADConnectorUser(request *ConfigADConnectorUserRequest) (response *ConfigADConnectorUserResponse, err error)

ConfigADConnectorUser invokes the ecd.ConfigADConnectorUser API synchronously

func (*Client) ConfigADConnectorUserWithCallback ¶

func (client *Client) ConfigADConnectorUserWithCallback(request *ConfigADConnectorUserRequest, callback func(response *ConfigADConnectorUserResponse, err error)) <-chan int

ConfigADConnectorUserWithCallback invokes the ecd.ConfigADConnectorUser API asynchronously

func (*Client) ConfigADConnectorUserWithChan ¶

func (client *Client) ConfigADConnectorUserWithChan(request *ConfigADConnectorUserRequest) (<-chan *ConfigADConnectorUserResponse, <-chan error)

ConfigADConnectorUserWithChan invokes the ecd.ConfigADConnectorUser API asynchronously

func (*Client) CopyImage ¶

func (client *Client) CopyImage(request *CopyImageRequest) (response *CopyImageResponse, err error)

CopyImage invokes the ecd.CopyImage API synchronously

func (*Client) CopyImageWithCallback ¶

func (client *Client) CopyImageWithCallback(request *CopyImageRequest, callback func(response *CopyImageResponse, err error)) <-chan int

CopyImageWithCallback invokes the ecd.CopyImage API asynchronously

func (*Client) CopyImageWithChan ¶

func (client *Client) CopyImageWithChan(request *CopyImageRequest) (<-chan *CopyImageResponse, <-chan error)

CopyImageWithChan invokes the ecd.CopyImage API asynchronously

func (*Client) CreateADConnectorDirectory ¶

func (client *Client) CreateADConnectorDirectory(request *CreateADConnectorDirectoryRequest) (response *CreateADConnectorDirectoryResponse, err error)

CreateADConnectorDirectory invokes the ecd.CreateADConnectorDirectory API synchronously

func (*Client) CreateADConnectorDirectoryWithCallback ¶

func (client *Client) CreateADConnectorDirectoryWithCallback(request *CreateADConnectorDirectoryRequest, callback func(response *CreateADConnectorDirectoryResponse, err error)) <-chan int

CreateADConnectorDirectoryWithCallback invokes the ecd.CreateADConnectorDirectory API asynchronously

func (*Client) CreateADConnectorDirectoryWithChan ¶

func (client *Client) CreateADConnectorDirectoryWithChan(request *CreateADConnectorDirectoryRequest) (<-chan *CreateADConnectorDirectoryResponse, <-chan error)

CreateADConnectorDirectoryWithChan invokes the ecd.CreateADConnectorDirectory API asynchronously

func (*Client) CreateADConnectorOfficeSite ¶

func (client *Client) CreateADConnectorOfficeSite(request *CreateADConnectorOfficeSiteRequest) (response *CreateADConnectorOfficeSiteResponse, err error)

CreateADConnectorOfficeSite invokes the ecd.CreateADConnectorOfficeSite API synchronously

func (*Client) CreateADConnectorOfficeSiteWithCallback ¶

func (client *Client) CreateADConnectorOfficeSiteWithCallback(request *CreateADConnectorOfficeSiteRequest, callback func(response *CreateADConnectorOfficeSiteResponse, err error)) <-chan int

CreateADConnectorOfficeSiteWithCallback invokes the ecd.CreateADConnectorOfficeSite API asynchronously

func (*Client) CreateADConnectorOfficeSiteWithChan ¶

func (client *Client) CreateADConnectorOfficeSiteWithChan(request *CreateADConnectorOfficeSiteRequest) (<-chan *CreateADConnectorOfficeSiteResponse, <-chan error)

CreateADConnectorOfficeSiteWithChan invokes the ecd.CreateADConnectorOfficeSite API asynchronously

func (*Client) CreateBundle ¶

func (client *Client) CreateBundle(request *CreateBundleRequest) (response *CreateBundleResponse, err error)

CreateBundle invokes the ecd.CreateBundle API synchronously

func (*Client) CreateBundleWithCallback ¶

func (client *Client) CreateBundleWithCallback(request *CreateBundleRequest, callback func(response *CreateBundleResponse, err error)) <-chan int

CreateBundleWithCallback invokes the ecd.CreateBundle API asynchronously

func (*Client) CreateBundleWithChan ¶

func (client *Client) CreateBundleWithChan(request *CreateBundleRequest) (<-chan *CreateBundleResponse, <-chan error)

CreateBundleWithChan invokes the ecd.CreateBundle API asynchronously

func (*Client) CreateDesktopGroup ¶

func (client *Client) CreateDesktopGroup(request *CreateDesktopGroupRequest) (response *CreateDesktopGroupResponse, err error)

CreateDesktopGroup invokes the ecd.CreateDesktopGroup API synchronously

func (*Client) CreateDesktopGroupWithCallback ¶

func (client *Client) CreateDesktopGroupWithCallback(request *CreateDesktopGroupRequest, callback func(response *CreateDesktopGroupResponse, err error)) <-chan int

CreateDesktopGroupWithCallback invokes the ecd.CreateDesktopGroup API asynchronously

func (*Client) CreateDesktopGroupWithChan ¶

func (client *Client) CreateDesktopGroupWithChan(request *CreateDesktopGroupRequest) (<-chan *CreateDesktopGroupResponse, <-chan error)

CreateDesktopGroupWithChan invokes the ecd.CreateDesktopGroup API asynchronously

func (*Client) CreateDesktops ¶

func (client *Client) CreateDesktops(request *CreateDesktopsRequest) (response *CreateDesktopsResponse, err error)

CreateDesktops invokes the ecd.CreateDesktops API synchronously

func (*Client) CreateDesktopsWithCallback ¶

func (client *Client) CreateDesktopsWithCallback(request *CreateDesktopsRequest, callback func(response *CreateDesktopsResponse, err error)) <-chan int

CreateDesktopsWithCallback invokes the ecd.CreateDesktops API asynchronously

func (*Client) CreateDesktopsWithChan ¶

func (client *Client) CreateDesktopsWithChan(request *CreateDesktopsRequest) (<-chan *CreateDesktopsResponse, <-chan error)

CreateDesktopsWithChan invokes the ecd.CreateDesktops API asynchronously

func (*Client) CreateDiskEncryptionService ¶

func (client *Client) CreateDiskEncryptionService(request *CreateDiskEncryptionServiceRequest) (response *CreateDiskEncryptionServiceResponse, err error)

CreateDiskEncryptionService invokes the ecd.CreateDiskEncryptionService API synchronously

func (*Client) CreateDiskEncryptionServiceWithCallback ¶

func (client *Client) CreateDiskEncryptionServiceWithCallback(request *CreateDiskEncryptionServiceRequest, callback func(response *CreateDiskEncryptionServiceResponse, err error)) <-chan int

CreateDiskEncryptionServiceWithCallback invokes the ecd.CreateDiskEncryptionService API asynchronously

func (*Client) CreateDiskEncryptionServiceWithChan ¶

func (client *Client) CreateDiskEncryptionServiceWithChan(request *CreateDiskEncryptionServiceRequest) (<-chan *CreateDiskEncryptionServiceResponse, <-chan error)

CreateDiskEncryptionServiceWithChan invokes the ecd.CreateDiskEncryptionService API asynchronously

func (*Client) CreateImage ¶

func (client *Client) CreateImage(request *CreateImageRequest) (response *CreateImageResponse, err error)

CreateImage invokes the ecd.CreateImage API synchronously

func (*Client) CreateImageWithCallback ¶

func (client *Client) CreateImageWithCallback(request *CreateImageRequest, callback func(response *CreateImageResponse, err error)) <-chan int

CreateImageWithCallback invokes the ecd.CreateImage API asynchronously

func (*Client) CreateImageWithChan ¶

func (client *Client) CreateImageWithChan(request *CreateImageRequest) (<-chan *CreateImageResponse, <-chan error)

CreateImageWithChan invokes the ecd.CreateImage API asynchronously

func (*Client) CreateNASFileSystem ¶

func (client *Client) CreateNASFileSystem(request *CreateNASFileSystemRequest) (response *CreateNASFileSystemResponse, err error)

CreateNASFileSystem invokes the ecd.CreateNASFileSystem API synchronously

func (*Client) CreateNASFileSystemWithCallback ¶

func (client *Client) CreateNASFileSystemWithCallback(request *CreateNASFileSystemRequest, callback func(response *CreateNASFileSystemResponse, err error)) <-chan int

CreateNASFileSystemWithCallback invokes the ecd.CreateNASFileSystem API asynchronously

func (*Client) CreateNASFileSystemWithChan ¶

func (client *Client) CreateNASFileSystemWithChan(request *CreateNASFileSystemRequest) (<-chan *CreateNASFileSystemResponse, <-chan error)

CreateNASFileSystemWithChan invokes the ecd.CreateNASFileSystem API asynchronously

func (*Client) CreateNetworkPackage ¶

func (client *Client) CreateNetworkPackage(request *CreateNetworkPackageRequest) (response *CreateNetworkPackageResponse, err error)

CreateNetworkPackage invokes the ecd.CreateNetworkPackage API synchronously

func (*Client) CreateNetworkPackageWithCallback ¶

func (client *Client) CreateNetworkPackageWithCallback(request *CreateNetworkPackageRequest, callback func(response *CreateNetworkPackageResponse, err error)) <-chan int

CreateNetworkPackageWithCallback invokes the ecd.CreateNetworkPackage API asynchronously

func (*Client) CreateNetworkPackageWithChan ¶

func (client *Client) CreateNetworkPackageWithChan(request *CreateNetworkPackageRequest) (<-chan *CreateNetworkPackageResponse, <-chan error)

CreateNetworkPackageWithChan invokes the ecd.CreateNetworkPackage API asynchronously

func (*Client) CreatePolicyGroup ¶

func (client *Client) CreatePolicyGroup(request *CreatePolicyGroupRequest) (response *CreatePolicyGroupResponse, err error)

CreatePolicyGroup invokes the ecd.CreatePolicyGroup API synchronously

func (*Client) CreatePolicyGroupWithCallback ¶

func (client *Client) CreatePolicyGroupWithCallback(request *CreatePolicyGroupRequest, callback func(response *CreatePolicyGroupResponse, err error)) <-chan int

CreatePolicyGroupWithCallback invokes the ecd.CreatePolicyGroup API asynchronously

func (*Client) CreatePolicyGroupWithChan ¶

func (client *Client) CreatePolicyGroupWithChan(request *CreatePolicyGroupRequest) (<-chan *CreatePolicyGroupResponse, <-chan error)

CreatePolicyGroupWithChan invokes the ecd.CreatePolicyGroup API asynchronously

func (*Client) CreateRAMDirectory ¶

func (client *Client) CreateRAMDirectory(request *CreateRAMDirectoryRequest) (response *CreateRAMDirectoryResponse, err error)

CreateRAMDirectory invokes the ecd.CreateRAMDirectory API synchronously

func (*Client) CreateRAMDirectoryWithCallback ¶

func (client *Client) CreateRAMDirectoryWithCallback(request *CreateRAMDirectoryRequest, callback func(response *CreateRAMDirectoryResponse, err error)) <-chan int

CreateRAMDirectoryWithCallback invokes the ecd.CreateRAMDirectory API asynchronously

func (*Client) CreateRAMDirectoryWithChan ¶

func (client *Client) CreateRAMDirectoryWithChan(request *CreateRAMDirectoryRequest) (<-chan *CreateRAMDirectoryResponse, <-chan error)

CreateRAMDirectoryWithChan invokes the ecd.CreateRAMDirectory API asynchronously

func (*Client) CreateSimpleOfficeSite ¶

func (client *Client) CreateSimpleOfficeSite(request *CreateSimpleOfficeSiteRequest) (response *CreateSimpleOfficeSiteResponse, err error)

CreateSimpleOfficeSite invokes the ecd.CreateSimpleOfficeSite API synchronously

func (*Client) CreateSimpleOfficeSiteWithCallback ¶

func (client *Client) CreateSimpleOfficeSiteWithCallback(request *CreateSimpleOfficeSiteRequest, callback func(response *CreateSimpleOfficeSiteResponse, err error)) <-chan int

CreateSimpleOfficeSiteWithCallback invokes the ecd.CreateSimpleOfficeSite API asynchronously

func (*Client) CreateSimpleOfficeSiteWithChan ¶

func (client *Client) CreateSimpleOfficeSiteWithChan(request *CreateSimpleOfficeSiteRequest) (<-chan *CreateSimpleOfficeSiteResponse, <-chan error)

CreateSimpleOfficeSiteWithChan invokes the ecd.CreateSimpleOfficeSite API asynchronously

func (*Client) CreateSnapshot ¶

func (client *Client) CreateSnapshot(request *CreateSnapshotRequest) (response *CreateSnapshotResponse, err error)

CreateSnapshot invokes the ecd.CreateSnapshot API synchronously

func (*Client) CreateSnapshotWithCallback ¶

func (client *Client) CreateSnapshotWithCallback(request *CreateSnapshotRequest, callback func(response *CreateSnapshotResponse, err error)) <-chan int

CreateSnapshotWithCallback invokes the ecd.CreateSnapshot API asynchronously

func (*Client) CreateSnapshotWithChan ¶

func (client *Client) CreateSnapshotWithChan(request *CreateSnapshotRequest) (<-chan *CreateSnapshotResponse, <-chan error)

CreateSnapshotWithChan invokes the ecd.CreateSnapshot API asynchronously

func (*Client) DeleteBundles ¶

func (client *Client) DeleteBundles(request *DeleteBundlesRequest) (response *DeleteBundlesResponse, err error)

DeleteBundles invokes the ecd.DeleteBundles API synchronously

func (*Client) DeleteBundlesWithCallback ¶

func (client *Client) DeleteBundlesWithCallback(request *DeleteBundlesRequest, callback func(response *DeleteBundlesResponse, err error)) <-chan int

DeleteBundlesWithCallback invokes the ecd.DeleteBundles API asynchronously

func (*Client) DeleteBundlesWithChan ¶

func (client *Client) DeleteBundlesWithChan(request *DeleteBundlesRequest) (<-chan *DeleteBundlesResponse, <-chan error)

DeleteBundlesWithChan invokes the ecd.DeleteBundles API asynchronously

func (*Client) DeleteDesktopGroup ¶

func (client *Client) DeleteDesktopGroup(request *DeleteDesktopGroupRequest) (response *DeleteDesktopGroupResponse, err error)

DeleteDesktopGroup invokes the ecd.DeleteDesktopGroup API synchronously

func (*Client) DeleteDesktopGroupWithCallback ¶

func (client *Client) DeleteDesktopGroupWithCallback(request *DeleteDesktopGroupRequest, callback func(response *DeleteDesktopGroupResponse, err error)) <-chan int

DeleteDesktopGroupWithCallback invokes the ecd.DeleteDesktopGroup API asynchronously

func (*Client) DeleteDesktopGroupWithChan ¶

func (client *Client) DeleteDesktopGroupWithChan(request *DeleteDesktopGroupRequest) (<-chan *DeleteDesktopGroupResponse, <-chan error)

DeleteDesktopGroupWithChan invokes the ecd.DeleteDesktopGroup API asynchronously

func (*Client) DeleteDesktops ¶

func (client *Client) DeleteDesktops(request *DeleteDesktopsRequest) (response *DeleteDesktopsResponse, err error)

DeleteDesktops invokes the ecd.DeleteDesktops API synchronously

func (*Client) DeleteDesktopsWithCallback ¶

func (client *Client) DeleteDesktopsWithCallback(request *DeleteDesktopsRequest, callback func(response *DeleteDesktopsResponse, err error)) <-chan int

DeleteDesktopsWithCallback invokes the ecd.DeleteDesktops API asynchronously

func (*Client) DeleteDesktopsWithChan ¶

func (client *Client) DeleteDesktopsWithChan(request *DeleteDesktopsRequest) (<-chan *DeleteDesktopsResponse, <-chan error)

DeleteDesktopsWithChan invokes the ecd.DeleteDesktops API asynchronously

func (*Client) DeleteDirectories ¶

func (client *Client) DeleteDirectories(request *DeleteDirectoriesRequest) (response *DeleteDirectoriesResponse, err error)

DeleteDirectories invokes the ecd.DeleteDirectories API synchronously

func (*Client) DeleteDirectoriesWithCallback ¶

func (client *Client) DeleteDirectoriesWithCallback(request *DeleteDirectoriesRequest, callback func(response *DeleteDirectoriesResponse, err error)) <-chan int

DeleteDirectoriesWithCallback invokes the ecd.DeleteDirectories API asynchronously

func (*Client) DeleteDirectoriesWithChan ¶

func (client *Client) DeleteDirectoriesWithChan(request *DeleteDirectoriesRequest) (<-chan *DeleteDirectoriesResponse, <-chan error)

DeleteDirectoriesWithChan invokes the ecd.DeleteDirectories API asynchronously

func (*Client) DeleteImages ¶

func (client *Client) DeleteImages(request *DeleteImagesRequest) (response *DeleteImagesResponse, err error)

DeleteImages invokes the ecd.DeleteImages API synchronously

func (*Client) DeleteImagesWithCallback ¶

func (client *Client) DeleteImagesWithCallback(request *DeleteImagesRequest, callback func(response *DeleteImagesResponse, err error)) <-chan int

DeleteImagesWithCallback invokes the ecd.DeleteImages API asynchronously

func (*Client) DeleteImagesWithChan ¶

func (client *Client) DeleteImagesWithChan(request *DeleteImagesRequest) (<-chan *DeleteImagesResponse, <-chan error)

DeleteImagesWithChan invokes the ecd.DeleteImages API asynchronously

func (*Client) DeleteNASFileSystems ¶

func (client *Client) DeleteNASFileSystems(request *DeleteNASFileSystemsRequest) (response *DeleteNASFileSystemsResponse, err error)

DeleteNASFileSystems invokes the ecd.DeleteNASFileSystems API synchronously

func (*Client) DeleteNASFileSystemsWithCallback ¶

func (client *Client) DeleteNASFileSystemsWithCallback(request *DeleteNASFileSystemsRequest, callback func(response *DeleteNASFileSystemsResponse, err error)) <-chan int

DeleteNASFileSystemsWithCallback invokes the ecd.DeleteNASFileSystems API asynchronously

func (*Client) DeleteNASFileSystemsWithChan ¶

func (client *Client) DeleteNASFileSystemsWithChan(request *DeleteNASFileSystemsRequest) (<-chan *DeleteNASFileSystemsResponse, <-chan error)

DeleteNASFileSystemsWithChan invokes the ecd.DeleteNASFileSystems API asynchronously

func (*Client) DeleteNetworkPackages ¶

func (client *Client) DeleteNetworkPackages(request *DeleteNetworkPackagesRequest) (response *DeleteNetworkPackagesResponse, err error)

DeleteNetworkPackages invokes the ecd.DeleteNetworkPackages API synchronously

func (*Client) DeleteNetworkPackagesWithCallback ¶

func (client *Client) DeleteNetworkPackagesWithCallback(request *DeleteNetworkPackagesRequest, callback func(response *DeleteNetworkPackagesResponse, err error)) <-chan int

DeleteNetworkPackagesWithCallback invokes the ecd.DeleteNetworkPackages API asynchronously

func (*Client) DeleteNetworkPackagesWithChan ¶

func (client *Client) DeleteNetworkPackagesWithChan(request *DeleteNetworkPackagesRequest) (<-chan *DeleteNetworkPackagesResponse, <-chan error)

DeleteNetworkPackagesWithChan invokes the ecd.DeleteNetworkPackages API asynchronously

func (*Client) DeleteOfficeSites ¶

func (client *Client) DeleteOfficeSites(request *DeleteOfficeSitesRequest) (response *DeleteOfficeSitesResponse, err error)

DeleteOfficeSites invokes the ecd.DeleteOfficeSites API synchronously

func (*Client) DeleteOfficeSitesWithCallback ¶

func (client *Client) DeleteOfficeSitesWithCallback(request *DeleteOfficeSitesRequest, callback func(response *DeleteOfficeSitesResponse, err error)) <-chan int

DeleteOfficeSitesWithCallback invokes the ecd.DeleteOfficeSites API asynchronously

func (*Client) DeleteOfficeSitesWithChan ¶

func (client *Client) DeleteOfficeSitesWithChan(request *DeleteOfficeSitesRequest) (<-chan *DeleteOfficeSitesResponse, <-chan error)

DeleteOfficeSitesWithChan invokes the ecd.DeleteOfficeSites API asynchronously

func (*Client) DeletePolicyGroups ¶

func (client *Client) DeletePolicyGroups(request *DeletePolicyGroupsRequest) (response *DeletePolicyGroupsResponse, err error)

DeletePolicyGroups invokes the ecd.DeletePolicyGroups API synchronously

func (*Client) DeletePolicyGroupsWithCallback ¶

func (client *Client) DeletePolicyGroupsWithCallback(request *DeletePolicyGroupsRequest, callback func(response *DeletePolicyGroupsResponse, err error)) <-chan int

DeletePolicyGroupsWithCallback invokes the ecd.DeletePolicyGroups API asynchronously

func (*Client) DeletePolicyGroupsWithChan ¶

func (client *Client) DeletePolicyGroupsWithChan(request *DeletePolicyGroupsRequest) (<-chan *DeletePolicyGroupsResponse, <-chan error)

DeletePolicyGroupsWithChan invokes the ecd.DeletePolicyGroups API asynchronously

func (*Client) DeleteSnapshot ¶

func (client *Client) DeleteSnapshot(request *DeleteSnapshotRequest) (response *DeleteSnapshotResponse, err error)

DeleteSnapshot invokes the ecd.DeleteSnapshot API synchronously

func (*Client) DeleteSnapshotWithCallback ¶

func (client *Client) DeleteSnapshotWithCallback(request *DeleteSnapshotRequest, callback func(response *DeleteSnapshotResponse, err error)) <-chan int

DeleteSnapshotWithCallback invokes the ecd.DeleteSnapshot API asynchronously

func (*Client) DeleteSnapshotWithChan ¶

func (client *Client) DeleteSnapshotWithChan(request *DeleteSnapshotRequest) (<-chan *DeleteSnapshotResponse, <-chan error)

DeleteSnapshotWithChan invokes the ecd.DeleteSnapshot API asynchronously

func (*Client) DeleteVirtualMFADevice ¶

func (client *Client) DeleteVirtualMFADevice(request *DeleteVirtualMFADeviceRequest) (response *DeleteVirtualMFADeviceResponse, err error)

DeleteVirtualMFADevice invokes the ecd.DeleteVirtualMFADevice API synchronously

func (*Client) DeleteVirtualMFADeviceWithCallback ¶

func (client *Client) DeleteVirtualMFADeviceWithCallback(request *DeleteVirtualMFADeviceRequest, callback func(response *DeleteVirtualMFADeviceResponse, err error)) <-chan int

DeleteVirtualMFADeviceWithCallback invokes the ecd.DeleteVirtualMFADevice API asynchronously

func (*Client) DeleteVirtualMFADeviceWithChan ¶

func (client *Client) DeleteVirtualMFADeviceWithChan(request *DeleteVirtualMFADeviceRequest) (<-chan *DeleteVirtualMFADeviceResponse, <-chan error)

DeleteVirtualMFADeviceWithChan invokes the ecd.DeleteVirtualMFADevice API asynchronously

func (*Client) DescribeAlarmEventStackInfo ¶

func (client *Client) DescribeAlarmEventStackInfo(request *DescribeAlarmEventStackInfoRequest) (response *DescribeAlarmEventStackInfoResponse, err error)

DescribeAlarmEventStackInfo invokes the ecd.DescribeAlarmEventStackInfo API synchronously

func (*Client) DescribeAlarmEventStackInfoWithCallback ¶

func (client *Client) DescribeAlarmEventStackInfoWithCallback(request *DescribeAlarmEventStackInfoRequest, callback func(response *DescribeAlarmEventStackInfoResponse, err error)) <-chan int

DescribeAlarmEventStackInfoWithCallback invokes the ecd.DescribeAlarmEventStackInfo API asynchronously

func (*Client) DescribeAlarmEventStackInfoWithChan ¶

func (client *Client) DescribeAlarmEventStackInfoWithChan(request *DescribeAlarmEventStackInfoRequest) (<-chan *DescribeAlarmEventStackInfoResponse, <-chan error)

DescribeAlarmEventStackInfoWithChan invokes the ecd.DescribeAlarmEventStackInfo API asynchronously

func (*Client) DescribeBundles ¶

func (client *Client) DescribeBundles(request *DescribeBundlesRequest) (response *DescribeBundlesResponse, err error)

DescribeBundles invokes the ecd.DescribeBundles API synchronously

func (*Client) DescribeBundlesWithCallback ¶

func (client *Client) DescribeBundlesWithCallback(request *DescribeBundlesRequest, callback func(response *DescribeBundlesResponse, err error)) <-chan int

DescribeBundlesWithCallback invokes the ecd.DescribeBundles API asynchronously

func (*Client) DescribeBundlesWithChan ¶

func (client *Client) DescribeBundlesWithChan(request *DescribeBundlesRequest) (<-chan *DescribeBundlesResponse, <-chan error)

DescribeBundlesWithChan invokes the ecd.DescribeBundles API asynchronously

func (*Client) DescribeCens ¶

func (client *Client) DescribeCens(request *DescribeCensRequest) (response *DescribeCensResponse, err error)

DescribeCens invokes the ecd.DescribeCens API synchronously

func (*Client) DescribeCensWithCallback ¶

func (client *Client) DescribeCensWithCallback(request *DescribeCensRequest, callback func(response *DescribeCensResponse, err error)) <-chan int

DescribeCensWithCallback invokes the ecd.DescribeCens API asynchronously

func (*Client) DescribeCensWithChan ¶

func (client *Client) DescribeCensWithChan(request *DescribeCensRequest) (<-chan *DescribeCensResponse, <-chan error)

DescribeCensWithChan invokes the ecd.DescribeCens API asynchronously

func (*Client) DescribeClientEvents ¶

func (client *Client) DescribeClientEvents(request *DescribeClientEventsRequest) (response *DescribeClientEventsResponse, err error)

DescribeClientEvents invokes the ecd.DescribeClientEvents API synchronously

func (*Client) DescribeClientEventsWithCallback ¶

func (client *Client) DescribeClientEventsWithCallback(request *DescribeClientEventsRequest, callback func(response *DescribeClientEventsResponse, err error)) <-chan int

DescribeClientEventsWithCallback invokes the ecd.DescribeClientEvents API asynchronously

func (*Client) DescribeClientEventsWithChan ¶

func (client *Client) DescribeClientEventsWithChan(request *DescribeClientEventsRequest) (<-chan *DescribeClientEventsResponse, <-chan error)

DescribeClientEventsWithChan invokes the ecd.DescribeClientEvents API asynchronously

func (*Client) DescribeDesktopGroups ¶

func (client *Client) DescribeDesktopGroups(request *DescribeDesktopGroupsRequest) (response *DescribeDesktopGroupsResponse, err error)

DescribeDesktopGroups invokes the ecd.DescribeDesktopGroups API synchronously

func (*Client) DescribeDesktopGroupsWithCallback ¶

func (client *Client) DescribeDesktopGroupsWithCallback(request *DescribeDesktopGroupsRequest, callback func(response *DescribeDesktopGroupsResponse, err error)) <-chan int

DescribeDesktopGroupsWithCallback invokes the ecd.DescribeDesktopGroups API asynchronously

func (*Client) DescribeDesktopGroupsWithChan ¶

func (client *Client) DescribeDesktopGroupsWithChan(request *DescribeDesktopGroupsRequest) (<-chan *DescribeDesktopGroupsResponse, <-chan error)

DescribeDesktopGroupsWithChan invokes the ecd.DescribeDesktopGroups API asynchronously

func (*Client) DescribeDesktopIdsByVulNames ¶

func (client *Client) DescribeDesktopIdsByVulNames(request *DescribeDesktopIdsByVulNamesRequest) (response *DescribeDesktopIdsByVulNamesResponse, err error)

DescribeDesktopIdsByVulNames invokes the ecd.DescribeDesktopIdsByVulNames API synchronously

func (*Client) DescribeDesktopIdsByVulNamesWithCallback ¶

func (client *Client) DescribeDesktopIdsByVulNamesWithCallback(request *DescribeDesktopIdsByVulNamesRequest, callback func(response *DescribeDesktopIdsByVulNamesResponse, err error)) <-chan int

DescribeDesktopIdsByVulNamesWithCallback invokes the ecd.DescribeDesktopIdsByVulNames API asynchronously

func (*Client) DescribeDesktopIdsByVulNamesWithChan ¶

func (client *Client) DescribeDesktopIdsByVulNamesWithChan(request *DescribeDesktopIdsByVulNamesRequest) (<-chan *DescribeDesktopIdsByVulNamesResponse, <-chan error)

DescribeDesktopIdsByVulNamesWithChan invokes the ecd.DescribeDesktopIdsByVulNames API asynchronously

func (*Client) DescribeDesktopTypes ¶

func (client *Client) DescribeDesktopTypes(request *DescribeDesktopTypesRequest) (response *DescribeDesktopTypesResponse, err error)

DescribeDesktopTypes invokes the ecd.DescribeDesktopTypes API synchronously

func (*Client) DescribeDesktopTypesWithCallback ¶

func (client *Client) DescribeDesktopTypesWithCallback(request *DescribeDesktopTypesRequest, callback func(response *DescribeDesktopTypesResponse, err error)) <-chan int

DescribeDesktopTypesWithCallback invokes the ecd.DescribeDesktopTypes API asynchronously

func (*Client) DescribeDesktopTypesWithChan ¶

func (client *Client) DescribeDesktopTypesWithChan(request *DescribeDesktopTypesRequest) (<-chan *DescribeDesktopTypesResponse, <-chan error)

DescribeDesktopTypesWithChan invokes the ecd.DescribeDesktopTypes API asynchronously

func (*Client) DescribeDesktops ¶

func (client *Client) DescribeDesktops(request *DescribeDesktopsRequest) (response *DescribeDesktopsResponse, err error)

DescribeDesktops invokes the ecd.DescribeDesktops API synchronously

func (*Client) DescribeDesktopsInGroup ¶

func (client *Client) DescribeDesktopsInGroup(request *DescribeDesktopsInGroupRequest) (response *DescribeDesktopsInGroupResponse, err error)

DescribeDesktopsInGroup invokes the ecd.DescribeDesktopsInGroup API synchronously

func (*Client) DescribeDesktopsInGroupWithCallback ¶

func (client *Client) DescribeDesktopsInGroupWithCallback(request *DescribeDesktopsInGroupRequest, callback func(response *DescribeDesktopsInGroupResponse, err error)) <-chan int

DescribeDesktopsInGroupWithCallback invokes the ecd.DescribeDesktopsInGroup API asynchronously

func (*Client) DescribeDesktopsInGroupWithChan ¶

func (client *Client) DescribeDesktopsInGroupWithChan(request *DescribeDesktopsInGroupRequest) (<-chan *DescribeDesktopsInGroupResponse, <-chan error)

DescribeDesktopsInGroupWithChan invokes the ecd.DescribeDesktopsInGroup API asynchronously

func (*Client) DescribeDesktopsWithCallback ¶

func (client *Client) DescribeDesktopsWithCallback(request *DescribeDesktopsRequest, callback func(response *DescribeDesktopsResponse, err error)) <-chan int

DescribeDesktopsWithCallback invokes the ecd.DescribeDesktops API asynchronously

func (*Client) DescribeDesktopsWithChan ¶

func (client *Client) DescribeDesktopsWithChan(request *DescribeDesktopsRequest) (<-chan *DescribeDesktopsResponse, <-chan error)

DescribeDesktopsWithChan invokes the ecd.DescribeDesktops API asynchronously

func (*Client) DescribeDirectories ¶

func (client *Client) DescribeDirectories(request *DescribeDirectoriesRequest) (response *DescribeDirectoriesResponse, err error)

DescribeDirectories invokes the ecd.DescribeDirectories API synchronously

func (*Client) DescribeDirectoriesWithCallback ¶

func (client *Client) DescribeDirectoriesWithCallback(request *DescribeDirectoriesRequest, callback func(response *DescribeDirectoriesResponse, err error)) <-chan int

DescribeDirectoriesWithCallback invokes the ecd.DescribeDirectories API asynchronously

func (*Client) DescribeDirectoriesWithChan ¶

func (client *Client) DescribeDirectoriesWithChan(request *DescribeDirectoriesRequest) (<-chan *DescribeDirectoriesResponse, <-chan error)

DescribeDirectoriesWithChan invokes the ecd.DescribeDirectories API asynchronously

func (*Client) DescribeFlowMetric ¶

func (client *Client) DescribeFlowMetric(request *DescribeFlowMetricRequest) (response *DescribeFlowMetricResponse, err error)

DescribeFlowMetric invokes the ecd.DescribeFlowMetric API synchronously

func (*Client) DescribeFlowMetricWithCallback ¶

func (client *Client) DescribeFlowMetricWithCallback(request *DescribeFlowMetricRequest, callback func(response *DescribeFlowMetricResponse, err error)) <-chan int

DescribeFlowMetricWithCallback invokes the ecd.DescribeFlowMetric API asynchronously

func (*Client) DescribeFlowMetricWithChan ¶

func (client *Client) DescribeFlowMetricWithChan(request *DescribeFlowMetricRequest) (<-chan *DescribeFlowMetricResponse, <-chan error)

DescribeFlowMetricWithChan invokes the ecd.DescribeFlowMetric API asynchronously

func (*Client) DescribeFlowStatistic ¶

func (client *Client) DescribeFlowStatistic(request *DescribeFlowStatisticRequest) (response *DescribeFlowStatisticResponse, err error)

DescribeFlowStatistic invokes the ecd.DescribeFlowStatistic API synchronously

func (*Client) DescribeFlowStatisticWithCallback ¶

func (client *Client) DescribeFlowStatisticWithCallback(request *DescribeFlowStatisticRequest, callback func(response *DescribeFlowStatisticResponse, err error)) <-chan int

DescribeFlowStatisticWithCallback invokes the ecd.DescribeFlowStatistic API asynchronously

func (*Client) DescribeFlowStatisticWithChan ¶

func (client *Client) DescribeFlowStatisticWithChan(request *DescribeFlowStatisticRequest) (<-chan *DescribeFlowStatisticResponse, <-chan error)

DescribeFlowStatisticWithChan invokes the ecd.DescribeFlowStatistic API asynchronously

func (*Client) DescribeFotaPendingDesktops ¶

func (client *Client) DescribeFotaPendingDesktops(request *DescribeFotaPendingDesktopsRequest) (response *DescribeFotaPendingDesktopsResponse, err error)

DescribeFotaPendingDesktops invokes the ecd.DescribeFotaPendingDesktops API synchronously

func (*Client) DescribeFotaPendingDesktopsWithCallback ¶

func (client *Client) DescribeFotaPendingDesktopsWithCallback(request *DescribeFotaPendingDesktopsRequest, callback func(response *DescribeFotaPendingDesktopsResponse, err error)) <-chan int

DescribeFotaPendingDesktopsWithCallback invokes the ecd.DescribeFotaPendingDesktops API asynchronously

func (*Client) DescribeFotaPendingDesktopsWithChan ¶

func (client *Client) DescribeFotaPendingDesktopsWithChan(request *DescribeFotaPendingDesktopsRequest) (<-chan *DescribeFotaPendingDesktopsResponse, <-chan error)

DescribeFotaPendingDesktopsWithChan invokes the ecd.DescribeFotaPendingDesktops API asynchronously

func (*Client) DescribeFotaTasks ¶

func (client *Client) DescribeFotaTasks(request *DescribeFotaTasksRequest) (response *DescribeFotaTasksResponse, err error)

DescribeFotaTasks invokes the ecd.DescribeFotaTasks API synchronously

func (*Client) DescribeFotaTasksWithCallback ¶

func (client *Client) DescribeFotaTasksWithCallback(request *DescribeFotaTasksRequest, callback func(response *DescribeFotaTasksResponse, err error)) <-chan int

DescribeFotaTasksWithCallback invokes the ecd.DescribeFotaTasks API asynchronously

func (*Client) DescribeFotaTasksWithChan ¶

func (client *Client) DescribeFotaTasksWithChan(request *DescribeFotaTasksRequest) (<-chan *DescribeFotaTasksResponse, <-chan error)

DescribeFotaTasksWithChan invokes the ecd.DescribeFotaTasks API asynchronously

func (*Client) DescribeFrontVulPatchList ¶

func (client *Client) DescribeFrontVulPatchList(request *DescribeFrontVulPatchListRequest) (response *DescribeFrontVulPatchListResponse, err error)

DescribeFrontVulPatchList invokes the ecd.DescribeFrontVulPatchList API synchronously

func (*Client) DescribeFrontVulPatchListWithCallback ¶

func (client *Client) DescribeFrontVulPatchListWithCallback(request *DescribeFrontVulPatchListRequest, callback func(response *DescribeFrontVulPatchListResponse, err error)) <-chan int

DescribeFrontVulPatchListWithCallback invokes the ecd.DescribeFrontVulPatchList API asynchronously

func (*Client) DescribeFrontVulPatchListWithChan ¶

func (client *Client) DescribeFrontVulPatchListWithChan(request *DescribeFrontVulPatchListRequest) (<-chan *DescribeFrontVulPatchListResponse, <-chan error)

DescribeFrontVulPatchListWithChan invokes the ecd.DescribeFrontVulPatchList API asynchronously

func (*Client) DescribeGroupedVul ¶

func (client *Client) DescribeGroupedVul(request *DescribeGroupedVulRequest) (response *DescribeGroupedVulResponse, err error)

DescribeGroupedVul invokes the ecd.DescribeGroupedVul API synchronously

func (*Client) DescribeGroupedVulWithCallback ¶

func (client *Client) DescribeGroupedVulWithCallback(request *DescribeGroupedVulRequest, callback func(response *DescribeGroupedVulResponse, err error)) <-chan int

DescribeGroupedVulWithCallback invokes the ecd.DescribeGroupedVul API asynchronously

func (*Client) DescribeGroupedVulWithChan ¶

func (client *Client) DescribeGroupedVulWithChan(request *DescribeGroupedVulRequest) (<-chan *DescribeGroupedVulResponse, <-chan error)

DescribeGroupedVulWithChan invokes the ecd.DescribeGroupedVul API asynchronously

func (*Client) DescribeImageModifiedRecords ¶

func (client *Client) DescribeImageModifiedRecords(request *DescribeImageModifiedRecordsRequest) (response *DescribeImageModifiedRecordsResponse, err error)

DescribeImageModifiedRecords invokes the ecd.DescribeImageModifiedRecords API synchronously

func (*Client) DescribeImageModifiedRecordsWithCallback ¶

func (client *Client) DescribeImageModifiedRecordsWithCallback(request *DescribeImageModifiedRecordsRequest, callback func(response *DescribeImageModifiedRecordsResponse, err error)) <-chan int

DescribeImageModifiedRecordsWithCallback invokes the ecd.DescribeImageModifiedRecords API asynchronously

func (*Client) DescribeImageModifiedRecordsWithChan ¶

func (client *Client) DescribeImageModifiedRecordsWithChan(request *DescribeImageModifiedRecordsRequest) (<-chan *DescribeImageModifiedRecordsResponse, <-chan error)

DescribeImageModifiedRecordsWithChan invokes the ecd.DescribeImageModifiedRecords API asynchronously

func (*Client) DescribeImagePermission ¶

func (client *Client) DescribeImagePermission(request *DescribeImagePermissionRequest) (response *DescribeImagePermissionResponse, err error)

DescribeImagePermission invokes the ecd.DescribeImagePermission API synchronously

func (*Client) DescribeImagePermissionWithCallback ¶

func (client *Client) DescribeImagePermissionWithCallback(request *DescribeImagePermissionRequest, callback func(response *DescribeImagePermissionResponse, err error)) <-chan int

DescribeImagePermissionWithCallback invokes the ecd.DescribeImagePermission API asynchronously

func (*Client) DescribeImagePermissionWithChan ¶

func (client *Client) DescribeImagePermissionWithChan(request *DescribeImagePermissionRequest) (<-chan *DescribeImagePermissionResponse, <-chan error)

DescribeImagePermissionWithChan invokes the ecd.DescribeImagePermission API asynchronously

func (*Client) DescribeImages ¶

func (client *Client) DescribeImages(request *DescribeImagesRequest) (response *DescribeImagesResponse, err error)

DescribeImages invokes the ecd.DescribeImages API synchronously

func (*Client) DescribeImagesWithCallback ¶

func (client *Client) DescribeImagesWithCallback(request *DescribeImagesRequest, callback func(response *DescribeImagesResponse, err error)) <-chan int

DescribeImagesWithCallback invokes the ecd.DescribeImages API asynchronously

func (*Client) DescribeImagesWithChan ¶

func (client *Client) DescribeImagesWithChan(request *DescribeImagesRequest) (<-chan *DescribeImagesResponse, <-chan error)

DescribeImagesWithChan invokes the ecd.DescribeImages API asynchronously

func (*Client) DescribeInvocations ¶

func (client *Client) DescribeInvocations(request *DescribeInvocationsRequest) (response *DescribeInvocationsResponse, err error)

DescribeInvocations invokes the ecd.DescribeInvocations API synchronously

func (*Client) DescribeInvocationsWithCallback ¶

func (client *Client) DescribeInvocationsWithCallback(request *DescribeInvocationsRequest, callback func(response *DescribeInvocationsResponse, err error)) <-chan int

DescribeInvocationsWithCallback invokes the ecd.DescribeInvocations API asynchronously

func (*Client) DescribeInvocationsWithChan ¶

func (client *Client) DescribeInvocationsWithChan(request *DescribeInvocationsRequest) (<-chan *DescribeInvocationsResponse, <-chan error)

DescribeInvocationsWithChan invokes the ecd.DescribeInvocations API asynchronously

func (*Client) DescribeKmsKeys ¶

func (client *Client) DescribeKmsKeys(request *DescribeKmsKeysRequest) (response *DescribeKmsKeysResponse, err error)

DescribeKmsKeys invokes the ecd.DescribeKmsKeys API synchronously

func (*Client) DescribeKmsKeysWithCallback ¶

func (client *Client) DescribeKmsKeysWithCallback(request *DescribeKmsKeysRequest, callback func(response *DescribeKmsKeysResponse, err error)) <-chan int

DescribeKmsKeysWithCallback invokes the ecd.DescribeKmsKeys API asynchronously

func (*Client) DescribeKmsKeysWithChan ¶

func (client *Client) DescribeKmsKeysWithChan(request *DescribeKmsKeysRequest) (<-chan *DescribeKmsKeysResponse, <-chan error)

DescribeKmsKeysWithChan invokes the ecd.DescribeKmsKeys API asynchronously

func (*Client) DescribeNASFileSystems ¶

func (client *Client) DescribeNASFileSystems(request *DescribeNASFileSystemsRequest) (response *DescribeNASFileSystemsResponse, err error)

DescribeNASFileSystems invokes the ecd.DescribeNASFileSystems API synchronously

func (*Client) DescribeNASFileSystemsWithCallback ¶

func (client *Client) DescribeNASFileSystemsWithCallback(request *DescribeNASFileSystemsRequest, callback func(response *DescribeNASFileSystemsResponse, err error)) <-chan int

DescribeNASFileSystemsWithCallback invokes the ecd.DescribeNASFileSystems API asynchronously

func (*Client) DescribeNASFileSystemsWithChan ¶

func (client *Client) DescribeNASFileSystemsWithChan(request *DescribeNASFileSystemsRequest) (<-chan *DescribeNASFileSystemsResponse, <-chan error)

DescribeNASFileSystemsWithChan invokes the ecd.DescribeNASFileSystems API asynchronously

func (*Client) DescribeNetworkPackages ¶

func (client *Client) DescribeNetworkPackages(request *DescribeNetworkPackagesRequest) (response *DescribeNetworkPackagesResponse, err error)

DescribeNetworkPackages invokes the ecd.DescribeNetworkPackages API synchronously

func (*Client) DescribeNetworkPackagesWithCallback ¶

func (client *Client) DescribeNetworkPackagesWithCallback(request *DescribeNetworkPackagesRequest, callback func(response *DescribeNetworkPackagesResponse, err error)) <-chan int

DescribeNetworkPackagesWithCallback invokes the ecd.DescribeNetworkPackages API asynchronously

func (*Client) DescribeNetworkPackagesWithChan ¶

func (client *Client) DescribeNetworkPackagesWithChan(request *DescribeNetworkPackagesRequest) (<-chan *DescribeNetworkPackagesResponse, <-chan error)

DescribeNetworkPackagesWithChan invokes the ecd.DescribeNetworkPackages API asynchronously

func (*Client) DescribeOfficeSites ¶

func (client *Client) DescribeOfficeSites(request *DescribeOfficeSitesRequest) (response *DescribeOfficeSitesResponse, err error)

DescribeOfficeSites invokes the ecd.DescribeOfficeSites API synchronously

func (*Client) DescribeOfficeSitesWithCallback ¶

func (client *Client) DescribeOfficeSitesWithCallback(request *DescribeOfficeSitesRequest, callback func(response *DescribeOfficeSitesResponse, err error)) <-chan int

DescribeOfficeSitesWithCallback invokes the ecd.DescribeOfficeSites API asynchronously

func (*Client) DescribeOfficeSitesWithChan ¶

func (client *Client) DescribeOfficeSitesWithChan(request *DescribeOfficeSitesRequest) (<-chan *DescribeOfficeSitesResponse, <-chan error)

DescribeOfficeSitesWithChan invokes the ecd.DescribeOfficeSites API asynchronously

func (*Client) DescribePolicyGroups ¶

func (client *Client) DescribePolicyGroups(request *DescribePolicyGroupsRequest) (response *DescribePolicyGroupsResponse, err error)

DescribePolicyGroups invokes the ecd.DescribePolicyGroups API synchronously

func (*Client) DescribePolicyGroupsWithCallback ¶

func (client *Client) DescribePolicyGroupsWithCallback(request *DescribePolicyGroupsRequest, callback func(response *DescribePolicyGroupsResponse, err error)) <-chan int

DescribePolicyGroupsWithCallback invokes the ecd.DescribePolicyGroups API asynchronously

func (*Client) DescribePolicyGroupsWithChan ¶

func (client *Client) DescribePolicyGroupsWithChan(request *DescribePolicyGroupsRequest) (<-chan *DescribePolicyGroupsResponse, <-chan error)

DescribePolicyGroupsWithChan invokes the ecd.DescribePolicyGroups API asynchronously

func (*Client) DescribeRecordings ¶

func (client *Client) DescribeRecordings(request *DescribeRecordingsRequest) (response *DescribeRecordingsResponse, err error)

DescribeRecordings invokes the ecd.DescribeRecordings API synchronously

func (*Client) DescribeRecordingsWithCallback ¶

func (client *Client) DescribeRecordingsWithCallback(request *DescribeRecordingsRequest, callback func(response *DescribeRecordingsResponse, err error)) <-chan int

DescribeRecordingsWithCallback invokes the ecd.DescribeRecordings API asynchronously

func (*Client) DescribeRecordingsWithChan ¶

func (client *Client) DescribeRecordingsWithChan(request *DescribeRecordingsRequest) (<-chan *DescribeRecordingsResponse, <-chan error)

DescribeRecordingsWithChan invokes the ecd.DescribeRecordings API asynchronously

func (*Client) DescribeRegions ¶

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

DescribeRegions invokes the ecd.DescribeRegions API synchronously

func (*Client) DescribeRegionsWithCallback ¶

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

DescribeRegionsWithCallback invokes the ecd.DescribeRegions API asynchronously

func (*Client) DescribeRegionsWithChan ¶

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

DescribeRegionsWithChan invokes the ecd.DescribeRegions API asynchronously

func (*Client) DescribeScanTaskProgress ¶

func (client *Client) DescribeScanTaskProgress(request *DescribeScanTaskProgressRequest) (response *DescribeScanTaskProgressResponse, err error)

DescribeScanTaskProgress invokes the ecd.DescribeScanTaskProgress API synchronously

func (*Client) DescribeScanTaskProgressWithCallback ¶

func (client *Client) DescribeScanTaskProgressWithCallback(request *DescribeScanTaskProgressRequest, callback func(response *DescribeScanTaskProgressResponse, err error)) <-chan int

DescribeScanTaskProgressWithCallback invokes the ecd.DescribeScanTaskProgress API asynchronously

func (*Client) DescribeScanTaskProgressWithChan ¶

func (client *Client) DescribeScanTaskProgressWithChan(request *DescribeScanTaskProgressRequest) (<-chan *DescribeScanTaskProgressResponse, <-chan error)

DescribeScanTaskProgressWithChan invokes the ecd.DescribeScanTaskProgress API asynchronously

func (*Client) DescribeSecurityEventOperationStatus ¶

func (client *Client) DescribeSecurityEventOperationStatus(request *DescribeSecurityEventOperationStatusRequest) (response *DescribeSecurityEventOperationStatusResponse, err error)

DescribeSecurityEventOperationStatus invokes the ecd.DescribeSecurityEventOperationStatus API synchronously

func (*Client) DescribeSecurityEventOperationStatusWithCallback ¶

func (client *Client) DescribeSecurityEventOperationStatusWithCallback(request *DescribeSecurityEventOperationStatusRequest, callback func(response *DescribeSecurityEventOperationStatusResponse, err error)) <-chan int

DescribeSecurityEventOperationStatusWithCallback invokes the ecd.DescribeSecurityEventOperationStatus API asynchronously

func (*Client) DescribeSecurityEventOperationStatusWithChan ¶

func (client *Client) DescribeSecurityEventOperationStatusWithChan(request *DescribeSecurityEventOperationStatusRequest) (<-chan *DescribeSecurityEventOperationStatusResponse, <-chan error)

DescribeSecurityEventOperationStatusWithChan invokes the ecd.DescribeSecurityEventOperationStatus API asynchronously

func (*Client) DescribeSecurityEventOperations ¶

func (client *Client) DescribeSecurityEventOperations(request *DescribeSecurityEventOperationsRequest) (response *DescribeSecurityEventOperationsResponse, err error)

DescribeSecurityEventOperations invokes the ecd.DescribeSecurityEventOperations API synchronously

func (*Client) DescribeSecurityEventOperationsWithCallback ¶

func (client *Client) DescribeSecurityEventOperationsWithCallback(request *DescribeSecurityEventOperationsRequest, callback func(response *DescribeSecurityEventOperationsResponse, err error)) <-chan int

DescribeSecurityEventOperationsWithCallback invokes the ecd.DescribeSecurityEventOperations API asynchronously

func (*Client) DescribeSecurityEventOperationsWithChan ¶

func (client *Client) DescribeSecurityEventOperationsWithChan(request *DescribeSecurityEventOperationsRequest) (<-chan *DescribeSecurityEventOperationsResponse, <-chan error)

DescribeSecurityEventOperationsWithChan invokes the ecd.DescribeSecurityEventOperations API asynchronously

func (*Client) DescribeSnapshots ¶

func (client *Client) DescribeSnapshots(request *DescribeSnapshotsRequest) (response *DescribeSnapshotsResponse, err error)

DescribeSnapshots invokes the ecd.DescribeSnapshots API synchronously

func (*Client) DescribeSnapshotsWithCallback ¶

func (client *Client) DescribeSnapshotsWithCallback(request *DescribeSnapshotsRequest, callback func(response *DescribeSnapshotsResponse, err error)) <-chan int

DescribeSnapshotsWithCallback invokes the ecd.DescribeSnapshots API asynchronously

func (*Client) DescribeSnapshotsWithChan ¶

func (client *Client) DescribeSnapshotsWithChan(request *DescribeSnapshotsRequest) (<-chan *DescribeSnapshotsResponse, <-chan error)

DescribeSnapshotsWithChan invokes the ecd.DescribeSnapshots API asynchronously

func (*Client) DescribeSuspEventOverview ¶

func (client *Client) DescribeSuspEventOverview(request *DescribeSuspEventOverviewRequest) (response *DescribeSuspEventOverviewResponse, err error)

DescribeSuspEventOverview invokes the ecd.DescribeSuspEventOverview API synchronously

func (*Client) DescribeSuspEventOverviewWithCallback ¶

func (client *Client) DescribeSuspEventOverviewWithCallback(request *DescribeSuspEventOverviewRequest, callback func(response *DescribeSuspEventOverviewResponse, err error)) <-chan int

DescribeSuspEventOverviewWithCallback invokes the ecd.DescribeSuspEventOverview API asynchronously

func (*Client) DescribeSuspEventOverviewWithChan ¶

func (client *Client) DescribeSuspEventOverviewWithChan(request *DescribeSuspEventOverviewRequest) (<-chan *DescribeSuspEventOverviewResponse, <-chan error)

DescribeSuspEventOverviewWithChan invokes the ecd.DescribeSuspEventOverview API asynchronously

func (*Client) DescribeSuspEventQuaraFiles ¶

func (client *Client) DescribeSuspEventQuaraFiles(request *DescribeSuspEventQuaraFilesRequest) (response *DescribeSuspEventQuaraFilesResponse, err error)

DescribeSuspEventQuaraFiles invokes the ecd.DescribeSuspEventQuaraFiles API synchronously

func (*Client) DescribeSuspEventQuaraFilesWithCallback ¶

func (client *Client) DescribeSuspEventQuaraFilesWithCallback(request *DescribeSuspEventQuaraFilesRequest, callback func(response *DescribeSuspEventQuaraFilesResponse, err error)) <-chan int

DescribeSuspEventQuaraFilesWithCallback invokes the ecd.DescribeSuspEventQuaraFiles API asynchronously

func (*Client) DescribeSuspEventQuaraFilesWithChan ¶

func (client *Client) DescribeSuspEventQuaraFilesWithChan(request *DescribeSuspEventQuaraFilesRequest) (<-chan *DescribeSuspEventQuaraFilesResponse, <-chan error)

DescribeSuspEventQuaraFilesWithChan invokes the ecd.DescribeSuspEventQuaraFiles API asynchronously

func (*Client) DescribeSuspEvents ¶

func (client *Client) DescribeSuspEvents(request *DescribeSuspEventsRequest) (response *DescribeSuspEventsResponse, err error)

DescribeSuspEvents invokes the ecd.DescribeSuspEvents API synchronously

func (*Client) DescribeSuspEventsWithCallback ¶

func (client *Client) DescribeSuspEventsWithCallback(request *DescribeSuspEventsRequest, callback func(response *DescribeSuspEventsResponse, err error)) <-chan int

DescribeSuspEventsWithCallback invokes the ecd.DescribeSuspEvents API asynchronously

func (*Client) DescribeSuspEventsWithChan ¶

func (client *Client) DescribeSuspEventsWithChan(request *DescribeSuspEventsRequest) (<-chan *DescribeSuspEventsResponse, <-chan error)

DescribeSuspEventsWithChan invokes the ecd.DescribeSuspEvents API asynchronously

func (*Client) DescribeUserConnectionRecords ¶

func (client *Client) DescribeUserConnectionRecords(request *DescribeUserConnectionRecordsRequest) (response *DescribeUserConnectionRecordsResponse, err error)

DescribeUserConnectionRecords invokes the ecd.DescribeUserConnectionRecords API synchronously

func (*Client) DescribeUserConnectionRecordsWithCallback ¶

func (client *Client) DescribeUserConnectionRecordsWithCallback(request *DescribeUserConnectionRecordsRequest, callback func(response *DescribeUserConnectionRecordsResponse, err error)) <-chan int

DescribeUserConnectionRecordsWithCallback invokes the ecd.DescribeUserConnectionRecords API asynchronously

func (*Client) DescribeUserConnectionRecordsWithChan ¶

func (client *Client) DescribeUserConnectionRecordsWithChan(request *DescribeUserConnectionRecordsRequest) (<-chan *DescribeUserConnectionRecordsResponse, <-chan error)

DescribeUserConnectionRecordsWithChan invokes the ecd.DescribeUserConnectionRecords API asynchronously

func (*Client) DescribeUsersInGroup ¶

func (client *Client) DescribeUsersInGroup(request *DescribeUsersInGroupRequest) (response *DescribeUsersInGroupResponse, err error)

DescribeUsersInGroup invokes the ecd.DescribeUsersInGroup API synchronously

func (*Client) DescribeUsersInGroupWithCallback ¶

func (client *Client) DescribeUsersInGroupWithCallback(request *DescribeUsersInGroupRequest, callback func(response *DescribeUsersInGroupResponse, err error)) <-chan int

DescribeUsersInGroupWithCallback invokes the ecd.DescribeUsersInGroup API asynchronously

func (*Client) DescribeUsersInGroupWithChan ¶

func (client *Client) DescribeUsersInGroupWithChan(request *DescribeUsersInGroupRequest) (<-chan *DescribeUsersInGroupResponse, <-chan error)

DescribeUsersInGroupWithChan invokes the ecd.DescribeUsersInGroup API asynchronously

func (*Client) DescribeVirtualMFADevices ¶

func (client *Client) DescribeVirtualMFADevices(request *DescribeVirtualMFADevicesRequest) (response *DescribeVirtualMFADevicesResponse, err error)

DescribeVirtualMFADevices invokes the ecd.DescribeVirtualMFADevices API synchronously

func (*Client) DescribeVirtualMFADevicesWithCallback ¶

func (client *Client) DescribeVirtualMFADevicesWithCallback(request *DescribeVirtualMFADevicesRequest, callback func(response *DescribeVirtualMFADevicesResponse, err error)) <-chan int

DescribeVirtualMFADevicesWithCallback invokes the ecd.DescribeVirtualMFADevices API asynchronously

func (*Client) DescribeVirtualMFADevicesWithChan ¶

func (client *Client) DescribeVirtualMFADevicesWithChan(request *DescribeVirtualMFADevicesRequest) (<-chan *DescribeVirtualMFADevicesResponse, <-chan error)

DescribeVirtualMFADevicesWithChan invokes the ecd.DescribeVirtualMFADevices API asynchronously

func (*Client) DescribeVulDetails ¶

func (client *Client) DescribeVulDetails(request *DescribeVulDetailsRequest) (response *DescribeVulDetailsResponse, err error)

DescribeVulDetails invokes the ecd.DescribeVulDetails API synchronously

func (*Client) DescribeVulDetailsWithCallback ¶

func (client *Client) DescribeVulDetailsWithCallback(request *DescribeVulDetailsRequest, callback func(response *DescribeVulDetailsResponse, err error)) <-chan int

DescribeVulDetailsWithCallback invokes the ecd.DescribeVulDetails API asynchronously

func (*Client) DescribeVulDetailsWithChan ¶

func (client *Client) DescribeVulDetailsWithChan(request *DescribeVulDetailsRequest) (<-chan *DescribeVulDetailsResponse, <-chan error)

DescribeVulDetailsWithChan invokes the ecd.DescribeVulDetails API asynchronously

func (*Client) DescribeVulList ¶

func (client *Client) DescribeVulList(request *DescribeVulListRequest) (response *DescribeVulListResponse, err error)

DescribeVulList invokes the ecd.DescribeVulList API synchronously

func (*Client) DescribeVulListWithCallback ¶

func (client *Client) DescribeVulListWithCallback(request *DescribeVulListRequest, callback func(response *DescribeVulListResponse, err error)) <-chan int

DescribeVulListWithCallback invokes the ecd.DescribeVulList API asynchronously

func (*Client) DescribeVulListWithChan ¶

func (client *Client) DescribeVulListWithChan(request *DescribeVulListRequest) (<-chan *DescribeVulListResponse, <-chan error)

DescribeVulListWithChan invokes the ecd.DescribeVulList API asynchronously

func (*Client) DescribeVulOverview ¶

func (client *Client) DescribeVulOverview(request *DescribeVulOverviewRequest) (response *DescribeVulOverviewResponse, err error)

DescribeVulOverview invokes the ecd.DescribeVulOverview API synchronously

func (*Client) DescribeVulOverviewWithCallback ¶

func (client *Client) DescribeVulOverviewWithCallback(request *DescribeVulOverviewRequest, callback func(response *DescribeVulOverviewResponse, err error)) <-chan int

DescribeVulOverviewWithCallback invokes the ecd.DescribeVulOverview API asynchronously

func (*Client) DescribeVulOverviewWithChan ¶

func (client *Client) DescribeVulOverviewWithChan(request *DescribeVulOverviewRequest) (<-chan *DescribeVulOverviewResponse, <-chan error)

DescribeVulOverviewWithChan invokes the ecd.DescribeVulOverview API asynchronously

func (*Client) DescribeZones ¶

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

DescribeZones invokes the ecd.DescribeZones API synchronously

func (*Client) DescribeZonesWithCallback ¶

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

DescribeZonesWithCallback invokes the ecd.DescribeZones API asynchronously

func (*Client) DescribeZonesWithChan ¶

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

DescribeZonesWithChan invokes the ecd.DescribeZones API asynchronously

func (*Client) DetachCen ¶

func (client *Client) DetachCen(request *DetachCenRequest) (response *DetachCenResponse, err error)

DetachCen invokes the ecd.DetachCen API synchronously

func (*Client) DetachCenWithCallback ¶

func (client *Client) DetachCenWithCallback(request *DetachCenRequest, callback func(response *DetachCenResponse, err error)) <-chan int

DetachCenWithCallback invokes the ecd.DetachCen API asynchronously

func (*Client) DetachCenWithChan ¶

func (client *Client) DetachCenWithChan(request *DetachCenRequest) (<-chan *DetachCenResponse, <-chan error)

DetachCenWithChan invokes the ecd.DetachCen API asynchronously

func (*Client) DisableDesktopsInGroup ¶

func (client *Client) DisableDesktopsInGroup(request *DisableDesktopsInGroupRequest) (response *DisableDesktopsInGroupResponse, err error)

DisableDesktopsInGroup invokes the ecd.DisableDesktopsInGroup API synchronously

func (*Client) DisableDesktopsInGroupWithCallback ¶

func (client *Client) DisableDesktopsInGroupWithCallback(request *DisableDesktopsInGroupRequest, callback func(response *DisableDesktopsInGroupResponse, err error)) <-chan int

DisableDesktopsInGroupWithCallback invokes the ecd.DisableDesktopsInGroup API asynchronously

func (*Client) DisableDesktopsInGroupWithChan ¶

func (client *Client) DisableDesktopsInGroupWithChan(request *DisableDesktopsInGroupRequest) (<-chan *DisableDesktopsInGroupResponse, <-chan error)

DisableDesktopsInGroupWithChan invokes the ecd.DisableDesktopsInGroup API asynchronously

func (*Client) DissociateNetworkPackage ¶

func (client *Client) DissociateNetworkPackage(request *DissociateNetworkPackageRequest) (response *DissociateNetworkPackageResponse, err error)

DissociateNetworkPackage invokes the ecd.DissociateNetworkPackage API synchronously

func (*Client) DissociateNetworkPackageWithCallback ¶

func (client *Client) DissociateNetworkPackageWithCallback(request *DissociateNetworkPackageRequest, callback func(response *DissociateNetworkPackageResponse, err error)) <-chan int

DissociateNetworkPackageWithCallback invokes the ecd.DissociateNetworkPackage API asynchronously

func (*Client) DissociateNetworkPackageWithChan ¶

func (client *Client) DissociateNetworkPackageWithChan(request *DissociateNetworkPackageRequest) (<-chan *DissociateNetworkPackageResponse, <-chan error)

DissociateNetworkPackageWithChan invokes the ecd.DissociateNetworkPackage API asynchronously

func (*Client) ExportClientEvents ¶

func (client *Client) ExportClientEvents(request *ExportClientEventsRequest) (response *ExportClientEventsResponse, err error)

ExportClientEvents invokes the ecd.ExportClientEvents API synchronously

func (*Client) ExportClientEventsWithCallback ¶

func (client *Client) ExportClientEventsWithCallback(request *ExportClientEventsRequest, callback func(response *ExportClientEventsResponse, err error)) <-chan int

ExportClientEventsWithCallback invokes the ecd.ExportClientEvents API asynchronously

func (*Client) ExportClientEventsWithChan ¶

func (client *Client) ExportClientEventsWithChan(request *ExportClientEventsRequest) (<-chan *ExportClientEventsResponse, <-chan error)

ExportClientEventsWithChan invokes the ecd.ExportClientEvents API asynchronously

func (*Client) ExportDesktopGroupInfo ¶

func (client *Client) ExportDesktopGroupInfo(request *ExportDesktopGroupInfoRequest) (response *ExportDesktopGroupInfoResponse, err error)

ExportDesktopGroupInfo invokes the ecd.ExportDesktopGroupInfo API synchronously

func (*Client) ExportDesktopGroupInfoWithCallback ¶

func (client *Client) ExportDesktopGroupInfoWithCallback(request *ExportDesktopGroupInfoRequest, callback func(response *ExportDesktopGroupInfoResponse, err error)) <-chan int

ExportDesktopGroupInfoWithCallback invokes the ecd.ExportDesktopGroupInfo API asynchronously

func (*Client) ExportDesktopGroupInfoWithChan ¶

func (client *Client) ExportDesktopGroupInfoWithChan(request *ExportDesktopGroupInfoRequest) (<-chan *ExportDesktopGroupInfoResponse, <-chan error)

ExportDesktopGroupInfoWithChan invokes the ecd.ExportDesktopGroupInfo API asynchronously

func (*Client) ExportDesktopListInfo ¶

func (client *Client) ExportDesktopListInfo(request *ExportDesktopListInfoRequest) (response *ExportDesktopListInfoResponse, err error)

ExportDesktopListInfo invokes the ecd.ExportDesktopListInfo API synchronously

func (*Client) ExportDesktopListInfoWithCallback ¶

func (client *Client) ExportDesktopListInfoWithCallback(request *ExportDesktopListInfoRequest, callback func(response *ExportDesktopListInfoResponse, err error)) <-chan int

ExportDesktopListInfoWithCallback invokes the ecd.ExportDesktopListInfo API asynchronously

func (*Client) ExportDesktopListInfoWithChan ¶

func (client *Client) ExportDesktopListInfoWithChan(request *ExportDesktopListInfoRequest) (<-chan *ExportDesktopListInfoResponse, <-chan error)

ExportDesktopListInfoWithChan invokes the ecd.ExportDesktopListInfo API asynchronously

func (*Client) GetConnectionTicket ¶

func (client *Client) GetConnectionTicket(request *GetConnectionTicketRequest) (response *GetConnectionTicketResponse, err error)

GetConnectionTicket invokes the ecd.GetConnectionTicket API synchronously

func (*Client) GetConnectionTicketWithCallback ¶

func (client *Client) GetConnectionTicketWithCallback(request *GetConnectionTicketRequest, callback func(response *GetConnectionTicketResponse, err error)) <-chan int

GetConnectionTicketWithCallback invokes the ecd.GetConnectionTicket API asynchronously

func (*Client) GetConnectionTicketWithChan ¶

func (client *Client) GetConnectionTicketWithChan(request *GetConnectionTicketRequest) (<-chan *GetConnectionTicketResponse, <-chan error)

GetConnectionTicketWithChan invokes the ecd.GetConnectionTicket API asynchronously

func (*Client) GetDesktopGroupDetail ¶

func (client *Client) GetDesktopGroupDetail(request *GetDesktopGroupDetailRequest) (response *GetDesktopGroupDetailResponse, err error)

GetDesktopGroupDetail invokes the ecd.GetDesktopGroupDetail API synchronously

func (*Client) GetDesktopGroupDetailWithCallback ¶

func (client *Client) GetDesktopGroupDetailWithCallback(request *GetDesktopGroupDetailRequest, callback func(response *GetDesktopGroupDetailResponse, err error)) <-chan int

GetDesktopGroupDetailWithCallback invokes the ecd.GetDesktopGroupDetail API asynchronously

func (*Client) GetDesktopGroupDetailWithChan ¶

func (client *Client) GetDesktopGroupDetailWithChan(request *GetDesktopGroupDetailRequest) (<-chan *GetDesktopGroupDetailResponse, <-chan error)

GetDesktopGroupDetailWithChan invokes the ecd.GetDesktopGroupDetail API asynchronously

func (*Client) GetDirectorySsoStatus ¶

func (client *Client) GetDirectorySsoStatus(request *GetDirectorySsoStatusRequest) (response *GetDirectorySsoStatusResponse, err error)

GetDirectorySsoStatus invokes the ecd.GetDirectorySsoStatus API synchronously

func (*Client) GetDirectorySsoStatusWithCallback ¶

func (client *Client) GetDirectorySsoStatusWithCallback(request *GetDirectorySsoStatusRequest, callback func(response *GetDirectorySsoStatusResponse, err error)) <-chan int

GetDirectorySsoStatusWithCallback invokes the ecd.GetDirectorySsoStatus API asynchronously

func (*Client) GetDirectorySsoStatusWithChan ¶

func (client *Client) GetDirectorySsoStatusWithChan(request *GetDirectorySsoStatusRequest) (<-chan *GetDirectorySsoStatusResponse, <-chan error)

GetDirectorySsoStatusWithChan invokes the ecd.GetDirectorySsoStatus API asynchronously

func (*Client) GetOfficeSiteSsoStatus ¶

func (client *Client) GetOfficeSiteSsoStatus(request *GetOfficeSiteSsoStatusRequest) (response *GetOfficeSiteSsoStatusResponse, err error)

GetOfficeSiteSsoStatus invokes the ecd.GetOfficeSiteSsoStatus API synchronously

func (*Client) GetOfficeSiteSsoStatusWithCallback ¶

func (client *Client) GetOfficeSiteSsoStatusWithCallback(request *GetOfficeSiteSsoStatusRequest, callback func(response *GetOfficeSiteSsoStatusResponse, err error)) <-chan int

GetOfficeSiteSsoStatusWithCallback invokes the ecd.GetOfficeSiteSsoStatus API asynchronously

func (*Client) GetOfficeSiteSsoStatusWithChan ¶

func (client *Client) GetOfficeSiteSsoStatusWithChan(request *GetOfficeSiteSsoStatusRequest) (<-chan *GetOfficeSiteSsoStatusResponse, <-chan error)

GetOfficeSiteSsoStatusWithChan invokes the ecd.GetOfficeSiteSsoStatus API asynchronously

func (*Client) GetSpMetadata ¶

func (client *Client) GetSpMetadata(request *GetSpMetadataRequest) (response *GetSpMetadataResponse, err error)

GetSpMetadata invokes the ecd.GetSpMetadata API synchronously

func (*Client) GetSpMetadataWithCallback ¶

func (client *Client) GetSpMetadataWithCallback(request *GetSpMetadataRequest, callback func(response *GetSpMetadataResponse, err error)) <-chan int

GetSpMetadataWithCallback invokes the ecd.GetSpMetadata API asynchronously

func (*Client) GetSpMetadataWithChan ¶

func (client *Client) GetSpMetadataWithChan(request *GetSpMetadataRequest) (<-chan *GetSpMetadataResponse, <-chan error)

GetSpMetadataWithChan invokes the ecd.GetSpMetadata API asynchronously

func (*Client) HandleSecurityEvents ¶

func (client *Client) HandleSecurityEvents(request *HandleSecurityEventsRequest) (response *HandleSecurityEventsResponse, err error)

HandleSecurityEvents invokes the ecd.HandleSecurityEvents API synchronously

func (*Client) HandleSecurityEventsWithCallback ¶

func (client *Client) HandleSecurityEventsWithCallback(request *HandleSecurityEventsRequest, callback func(response *HandleSecurityEventsResponse, err error)) <-chan int

HandleSecurityEventsWithCallback invokes the ecd.HandleSecurityEvents API asynchronously

func (*Client) HandleSecurityEventsWithChan ¶

func (client *Client) HandleSecurityEventsWithChan(request *HandleSecurityEventsRequest) (<-chan *HandleSecurityEventsResponse, <-chan error)

HandleSecurityEventsWithChan invokes the ecd.HandleSecurityEvents API asynchronously

func (*Client) ListDirectoryUsers ¶

func (client *Client) ListDirectoryUsers(request *ListDirectoryUsersRequest) (response *ListDirectoryUsersResponse, err error)

ListDirectoryUsers invokes the ecd.ListDirectoryUsers API synchronously

func (*Client) ListDirectoryUsersWithCallback ¶

func (client *Client) ListDirectoryUsersWithCallback(request *ListDirectoryUsersRequest, callback func(response *ListDirectoryUsersResponse, err error)) <-chan int

ListDirectoryUsersWithCallback invokes the ecd.ListDirectoryUsers API asynchronously

func (*Client) ListDirectoryUsersWithChan ¶

func (client *Client) ListDirectoryUsersWithChan(request *ListDirectoryUsersRequest) (<-chan *ListDirectoryUsersResponse, <-chan error)

ListDirectoryUsersWithChan invokes the ecd.ListDirectoryUsers API asynchronously

func (*Client) ListOfficeSiteOverview ¶

func (client *Client) ListOfficeSiteOverview(request *ListOfficeSiteOverviewRequest) (response *ListOfficeSiteOverviewResponse, err error)

ListOfficeSiteOverview invokes the ecd.ListOfficeSiteOverview API synchronously

func (*Client) ListOfficeSiteOverviewWithCallback ¶

func (client *Client) ListOfficeSiteOverviewWithCallback(request *ListOfficeSiteOverviewRequest, callback func(response *ListOfficeSiteOverviewResponse, err error)) <-chan int

ListOfficeSiteOverviewWithCallback invokes the ecd.ListOfficeSiteOverview API asynchronously

func (*Client) ListOfficeSiteOverviewWithChan ¶

func (client *Client) ListOfficeSiteOverviewWithChan(request *ListOfficeSiteOverviewRequest) (<-chan *ListOfficeSiteOverviewResponse, <-chan error)

ListOfficeSiteOverviewWithChan invokes the ecd.ListOfficeSiteOverview API asynchronously

func (*Client) ListOfficeSiteUsers ¶

func (client *Client) ListOfficeSiteUsers(request *ListOfficeSiteUsersRequest) (response *ListOfficeSiteUsersResponse, err error)

ListOfficeSiteUsers invokes the ecd.ListOfficeSiteUsers API synchronously

func (*Client) ListOfficeSiteUsersWithCallback ¶

func (client *Client) ListOfficeSiteUsersWithCallback(request *ListOfficeSiteUsersRequest, callback func(response *ListOfficeSiteUsersResponse, err error)) <-chan int

ListOfficeSiteUsersWithCallback invokes the ecd.ListOfficeSiteUsers API asynchronously

func (*Client) ListOfficeSiteUsersWithChan ¶

func (client *Client) ListOfficeSiteUsersWithChan(request *ListOfficeSiteUsersRequest) (<-chan *ListOfficeSiteUsersResponse, <-chan error)

ListOfficeSiteUsersWithChan invokes the ecd.ListOfficeSiteUsers API asynchronously

func (*Client) ListTagResources ¶

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

ListTagResources invokes the ecd.ListTagResources API synchronously

func (*Client) ListTagResourcesWithCallback ¶

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

ListTagResourcesWithCallback invokes the ecd.ListTagResources API asynchronously

func (*Client) ListTagResourcesWithChan ¶

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

ListTagResourcesWithChan invokes the ecd.ListTagResources API asynchronously

func (*Client) ListUserAdOrganizationUnits ¶

func (client *Client) ListUserAdOrganizationUnits(request *ListUserAdOrganizationUnitsRequest) (response *ListUserAdOrganizationUnitsResponse, err error)

ListUserAdOrganizationUnits invokes the ecd.ListUserAdOrganizationUnits API synchronously

func (*Client) ListUserAdOrganizationUnitsWithCallback ¶

func (client *Client) ListUserAdOrganizationUnitsWithCallback(request *ListUserAdOrganizationUnitsRequest, callback func(response *ListUserAdOrganizationUnitsResponse, err error)) <-chan int

ListUserAdOrganizationUnitsWithCallback invokes the ecd.ListUserAdOrganizationUnits API asynchronously

func (*Client) ListUserAdOrganizationUnitsWithChan ¶

func (client *Client) ListUserAdOrganizationUnitsWithChan(request *ListUserAdOrganizationUnitsRequest) (<-chan *ListUserAdOrganizationUnitsResponse, <-chan error)

ListUserAdOrganizationUnitsWithChan invokes the ecd.ListUserAdOrganizationUnits API asynchronously

func (*Client) LockVirtualMFADevice ¶

func (client *Client) LockVirtualMFADevice(request *LockVirtualMFADeviceRequest) (response *LockVirtualMFADeviceResponse, err error)

LockVirtualMFADevice invokes the ecd.LockVirtualMFADevice API synchronously

func (*Client) LockVirtualMFADeviceWithCallback ¶

func (client *Client) LockVirtualMFADeviceWithCallback(request *LockVirtualMFADeviceRequest, callback func(response *LockVirtualMFADeviceResponse, err error)) <-chan int

LockVirtualMFADeviceWithCallback invokes the ecd.LockVirtualMFADevice API asynchronously

func (*Client) LockVirtualMFADeviceWithChan ¶

func (client *Client) LockVirtualMFADeviceWithChan(request *LockVirtualMFADeviceRequest) (<-chan *LockVirtualMFADeviceResponse, <-chan error)

LockVirtualMFADeviceWithChan invokes the ecd.LockVirtualMFADevice API asynchronously

func (*Client) ModifyADConnectorDirectory ¶

func (client *Client) ModifyADConnectorDirectory(request *ModifyADConnectorDirectoryRequest) (response *ModifyADConnectorDirectoryResponse, err error)

ModifyADConnectorDirectory invokes the ecd.ModifyADConnectorDirectory API synchronously

func (*Client) ModifyADConnectorDirectoryWithCallback ¶

func (client *Client) ModifyADConnectorDirectoryWithCallback(request *ModifyADConnectorDirectoryRequest, callback func(response *ModifyADConnectorDirectoryResponse, err error)) <-chan int

ModifyADConnectorDirectoryWithCallback invokes the ecd.ModifyADConnectorDirectory API asynchronously

func (*Client) ModifyADConnectorDirectoryWithChan ¶

func (client *Client) ModifyADConnectorDirectoryWithChan(request *ModifyADConnectorDirectoryRequest) (<-chan *ModifyADConnectorDirectoryResponse, <-chan error)

ModifyADConnectorDirectoryWithChan invokes the ecd.ModifyADConnectorDirectory API asynchronously

func (*Client) ModifyADConnectorOfficeSite ¶

func (client *Client) ModifyADConnectorOfficeSite(request *ModifyADConnectorOfficeSiteRequest) (response *ModifyADConnectorOfficeSiteResponse, err error)

ModifyADConnectorOfficeSite invokes the ecd.ModifyADConnectorOfficeSite API synchronously

func (*Client) ModifyADConnectorOfficeSiteWithCallback ¶

func (client *Client) ModifyADConnectorOfficeSiteWithCallback(request *ModifyADConnectorOfficeSiteRequest, callback func(response *ModifyADConnectorOfficeSiteResponse, err error)) <-chan int

ModifyADConnectorOfficeSiteWithCallback invokes the ecd.ModifyADConnectorOfficeSite API asynchronously

func (*Client) ModifyADConnectorOfficeSiteWithChan ¶

func (client *Client) ModifyADConnectorOfficeSiteWithChan(request *ModifyADConnectorOfficeSiteRequest) (<-chan *ModifyADConnectorOfficeSiteResponse, <-chan error)

ModifyADConnectorOfficeSiteWithChan invokes the ecd.ModifyADConnectorOfficeSite API asynchronously

func (*Client) ModifyBundle ¶

func (client *Client) ModifyBundle(request *ModifyBundleRequest) (response *ModifyBundleResponse, err error)

ModifyBundle invokes the ecd.ModifyBundle API synchronously

func (*Client) ModifyBundleWithCallback ¶

func (client *Client) ModifyBundleWithCallback(request *ModifyBundleRequest, callback func(response *ModifyBundleResponse, err error)) <-chan int

ModifyBundleWithCallback invokes the ecd.ModifyBundle API asynchronously

func (*Client) ModifyBundleWithChan ¶

func (client *Client) ModifyBundleWithChan(request *ModifyBundleRequest) (<-chan *ModifyBundleResponse, <-chan error)

ModifyBundleWithChan invokes the ecd.ModifyBundle API asynchronously

func (*Client) ModifyDesktopChargeType ¶

func (client *Client) ModifyDesktopChargeType(request *ModifyDesktopChargeTypeRequest) (response *ModifyDesktopChargeTypeResponse, err error)

ModifyDesktopChargeType invokes the ecd.ModifyDesktopChargeType API synchronously

func (*Client) ModifyDesktopChargeTypeWithCallback ¶

func (client *Client) ModifyDesktopChargeTypeWithCallback(request *ModifyDesktopChargeTypeRequest, callback func(response *ModifyDesktopChargeTypeResponse, err error)) <-chan int

ModifyDesktopChargeTypeWithCallback invokes the ecd.ModifyDesktopChargeType API asynchronously

func (*Client) ModifyDesktopChargeTypeWithChan ¶

func (client *Client) ModifyDesktopChargeTypeWithChan(request *ModifyDesktopChargeTypeRequest) (<-chan *ModifyDesktopChargeTypeResponse, <-chan error)

ModifyDesktopChargeTypeWithChan invokes the ecd.ModifyDesktopChargeType API asynchronously

func (*Client) ModifyDesktopGroup ¶

func (client *Client) ModifyDesktopGroup(request *ModifyDesktopGroupRequest) (response *ModifyDesktopGroupResponse, err error)

ModifyDesktopGroup invokes the ecd.ModifyDesktopGroup API synchronously

func (*Client) ModifyDesktopGroupWithCallback ¶

func (client *Client) ModifyDesktopGroupWithCallback(request *ModifyDesktopGroupRequest, callback func(response *ModifyDesktopGroupResponse, err error)) <-chan int

ModifyDesktopGroupWithCallback invokes the ecd.ModifyDesktopGroup API asynchronously

func (*Client) ModifyDesktopGroupWithChan ¶

func (client *Client) ModifyDesktopGroupWithChan(request *ModifyDesktopGroupRequest) (<-chan *ModifyDesktopGroupResponse, <-chan error)

ModifyDesktopGroupWithChan invokes the ecd.ModifyDesktopGroup API asynchronously

func (*Client) ModifyDesktopHostName ¶

func (client *Client) ModifyDesktopHostName(request *ModifyDesktopHostNameRequest) (response *ModifyDesktopHostNameResponse, err error)

ModifyDesktopHostName invokes the ecd.ModifyDesktopHostName API synchronously

func (*Client) ModifyDesktopHostNameWithCallback ¶

func (client *Client) ModifyDesktopHostNameWithCallback(request *ModifyDesktopHostNameRequest, callback func(response *ModifyDesktopHostNameResponse, err error)) <-chan int

ModifyDesktopHostNameWithCallback invokes the ecd.ModifyDesktopHostName API asynchronously

func (*Client) ModifyDesktopHostNameWithChan ¶

func (client *Client) ModifyDesktopHostNameWithChan(request *ModifyDesktopHostNameRequest) (<-chan *ModifyDesktopHostNameResponse, <-chan error)

ModifyDesktopHostNameWithChan invokes the ecd.ModifyDesktopHostName API asynchronously

func (*Client) ModifyDesktopName ¶

func (client *Client) ModifyDesktopName(request *ModifyDesktopNameRequest) (response *ModifyDesktopNameResponse, err error)

ModifyDesktopName invokes the ecd.ModifyDesktopName API synchronously

func (*Client) ModifyDesktopNameWithCallback ¶

func (client *Client) ModifyDesktopNameWithCallback(request *ModifyDesktopNameRequest, callback func(response *ModifyDesktopNameResponse, err error)) <-chan int

ModifyDesktopNameWithCallback invokes the ecd.ModifyDesktopName API asynchronously

func (*Client) ModifyDesktopNameWithChan ¶

func (client *Client) ModifyDesktopNameWithChan(request *ModifyDesktopNameRequest) (<-chan *ModifyDesktopNameResponse, <-chan error)

ModifyDesktopNameWithChan invokes the ecd.ModifyDesktopName API asynchronously

func (*Client) ModifyDesktopSpec ¶

func (client *Client) ModifyDesktopSpec(request *ModifyDesktopSpecRequest) (response *ModifyDesktopSpecResponse, err error)

ModifyDesktopSpec invokes the ecd.ModifyDesktopSpec API synchronously

func (*Client) ModifyDesktopSpecWithCallback ¶

func (client *Client) ModifyDesktopSpecWithCallback(request *ModifyDesktopSpecRequest, callback func(response *ModifyDesktopSpecResponse, err error)) <-chan int

ModifyDesktopSpecWithCallback invokes the ecd.ModifyDesktopSpec API asynchronously

func (*Client) ModifyDesktopSpecWithChan ¶

func (client *Client) ModifyDesktopSpecWithChan(request *ModifyDesktopSpecRequest) (<-chan *ModifyDesktopSpecResponse, <-chan error)

ModifyDesktopSpecWithChan invokes the ecd.ModifyDesktopSpec API asynchronously

func (*Client) ModifyDesktopsPolicyGroup ¶

func (client *Client) ModifyDesktopsPolicyGroup(request *ModifyDesktopsPolicyGroupRequest) (response *ModifyDesktopsPolicyGroupResponse, err error)

ModifyDesktopsPolicyGroup invokes the ecd.ModifyDesktopsPolicyGroup API synchronously

func (*Client) ModifyDesktopsPolicyGroupWithCallback ¶

func (client *Client) ModifyDesktopsPolicyGroupWithCallback(request *ModifyDesktopsPolicyGroupRequest, callback func(response *ModifyDesktopsPolicyGroupResponse, err error)) <-chan int

ModifyDesktopsPolicyGroupWithCallback invokes the ecd.ModifyDesktopsPolicyGroup API asynchronously

func (*Client) ModifyDesktopsPolicyGroupWithChan ¶

func (client *Client) ModifyDesktopsPolicyGroupWithChan(request *ModifyDesktopsPolicyGroupRequest) (<-chan *ModifyDesktopsPolicyGroupResponse, <-chan error)

ModifyDesktopsPolicyGroupWithChan invokes the ecd.ModifyDesktopsPolicyGroup API asynchronously

func (*Client) ModifyDiskSpec ¶

func (client *Client) ModifyDiskSpec(request *ModifyDiskSpecRequest) (response *ModifyDiskSpecResponse, err error)

ModifyDiskSpec invokes the ecd.ModifyDiskSpec API synchronously

func (*Client) ModifyDiskSpecWithCallback ¶

func (client *Client) ModifyDiskSpecWithCallback(request *ModifyDiskSpecRequest, callback func(response *ModifyDiskSpecResponse, err error)) <-chan int

ModifyDiskSpecWithCallback invokes the ecd.ModifyDiskSpec API asynchronously

func (*Client) ModifyDiskSpecWithChan ¶

func (client *Client) ModifyDiskSpecWithChan(request *ModifyDiskSpecRequest) (<-chan *ModifyDiskSpecResponse, <-chan error)

ModifyDiskSpecWithChan invokes the ecd.ModifyDiskSpec API asynchronously

func (*Client) ModifyEntitlement ¶

func (client *Client) ModifyEntitlement(request *ModifyEntitlementRequest) (response *ModifyEntitlementResponse, err error)

ModifyEntitlement invokes the ecd.ModifyEntitlement API synchronously

func (*Client) ModifyEntitlementWithCallback ¶

func (client *Client) ModifyEntitlementWithCallback(request *ModifyEntitlementRequest, callback func(response *ModifyEntitlementResponse, err error)) <-chan int

ModifyEntitlementWithCallback invokes the ecd.ModifyEntitlement API asynchronously

func (*Client) ModifyEntitlementWithChan ¶

func (client *Client) ModifyEntitlementWithChan(request *ModifyEntitlementRequest) (<-chan *ModifyEntitlementResponse, <-chan error)

ModifyEntitlementWithChan invokes the ecd.ModifyEntitlement API asynchronously

func (*Client) ModifyImageAttribute ¶

func (client *Client) ModifyImageAttribute(request *ModifyImageAttributeRequest) (response *ModifyImageAttributeResponse, err error)

ModifyImageAttribute invokes the ecd.ModifyImageAttribute API synchronously

func (*Client) ModifyImageAttributeWithCallback ¶

func (client *Client) ModifyImageAttributeWithCallback(request *ModifyImageAttributeRequest, callback func(response *ModifyImageAttributeResponse, err error)) <-chan int

ModifyImageAttributeWithCallback invokes the ecd.ModifyImageAttribute API asynchronously

func (*Client) ModifyImageAttributeWithChan ¶

func (client *Client) ModifyImageAttributeWithChan(request *ModifyImageAttributeRequest) (<-chan *ModifyImageAttributeResponse, <-chan error)

ModifyImageAttributeWithChan invokes the ecd.ModifyImageAttribute API asynchronously

func (*Client) ModifyImagePermission ¶

func (client *Client) ModifyImagePermission(request *ModifyImagePermissionRequest) (response *ModifyImagePermissionResponse, err error)

ModifyImagePermission invokes the ecd.ModifyImagePermission API synchronously

func (*Client) ModifyImagePermissionWithCallback ¶

func (client *Client) ModifyImagePermissionWithCallback(request *ModifyImagePermissionRequest, callback func(response *ModifyImagePermissionResponse, err error)) <-chan int

ModifyImagePermissionWithCallback invokes the ecd.ModifyImagePermission API asynchronously

func (*Client) ModifyImagePermissionWithChan ¶

func (client *Client) ModifyImagePermissionWithChan(request *ModifyImagePermissionRequest) (<-chan *ModifyImagePermissionResponse, <-chan error)

ModifyImagePermissionWithChan invokes the ecd.ModifyImagePermission API asynchronously

func (*Client) ModifyNASDefaultMountTarget ¶

func (client *Client) ModifyNASDefaultMountTarget(request *ModifyNASDefaultMountTargetRequest) (response *ModifyNASDefaultMountTargetResponse, err error)

ModifyNASDefaultMountTarget invokes the ecd.ModifyNASDefaultMountTarget API synchronously

func (*Client) ModifyNASDefaultMountTargetWithCallback ¶

func (client *Client) ModifyNASDefaultMountTargetWithCallback(request *ModifyNASDefaultMountTargetRequest, callback func(response *ModifyNASDefaultMountTargetResponse, err error)) <-chan int

ModifyNASDefaultMountTargetWithCallback invokes the ecd.ModifyNASDefaultMountTarget API asynchronously

func (*Client) ModifyNASDefaultMountTargetWithChan ¶

func (client *Client) ModifyNASDefaultMountTargetWithChan(request *ModifyNASDefaultMountTargetRequest) (<-chan *ModifyNASDefaultMountTargetResponse, <-chan error)

ModifyNASDefaultMountTargetWithChan invokes the ecd.ModifyNASDefaultMountTarget API asynchronously

func (*Client) ModifyNetworkPackageBandwidth ¶

func (client *Client) ModifyNetworkPackageBandwidth(request *ModifyNetworkPackageBandwidthRequest) (response *ModifyNetworkPackageBandwidthResponse, err error)

ModifyNetworkPackageBandwidth invokes the ecd.ModifyNetworkPackageBandwidth API synchronously

func (*Client) ModifyNetworkPackageBandwidthWithCallback ¶

func (client *Client) ModifyNetworkPackageBandwidthWithCallback(request *ModifyNetworkPackageBandwidthRequest, callback func(response *ModifyNetworkPackageBandwidthResponse, err error)) <-chan int

ModifyNetworkPackageBandwidthWithCallback invokes the ecd.ModifyNetworkPackageBandwidth API asynchronously

func (*Client) ModifyNetworkPackageBandwidthWithChan ¶

func (client *Client) ModifyNetworkPackageBandwidthWithChan(request *ModifyNetworkPackageBandwidthRequest) (<-chan *ModifyNetworkPackageBandwidthResponse, <-chan error)

ModifyNetworkPackageBandwidthWithChan invokes the ecd.ModifyNetworkPackageBandwidth API asynchronously

func (*Client) ModifyNetworkPackageEnabled ¶

func (client *Client) ModifyNetworkPackageEnabled(request *ModifyNetworkPackageEnabledRequest) (response *ModifyNetworkPackageEnabledResponse, err error)

ModifyNetworkPackageEnabled invokes the ecd.ModifyNetworkPackageEnabled API synchronously

func (*Client) ModifyNetworkPackageEnabledWithCallback ¶

func (client *Client) ModifyNetworkPackageEnabledWithCallback(request *ModifyNetworkPackageEnabledRequest, callback func(response *ModifyNetworkPackageEnabledResponse, err error)) <-chan int

ModifyNetworkPackageEnabledWithCallback invokes the ecd.ModifyNetworkPackageEnabled API asynchronously

func (*Client) ModifyNetworkPackageEnabledWithChan ¶

func (client *Client) ModifyNetworkPackageEnabledWithChan(request *ModifyNetworkPackageEnabledRequest) (<-chan *ModifyNetworkPackageEnabledResponse, <-chan error)

ModifyNetworkPackageEnabledWithChan invokes the ecd.ModifyNetworkPackageEnabled API asynchronously

func (*Client) ModifyOfficeSiteAttribute ¶

func (client *Client) ModifyOfficeSiteAttribute(request *ModifyOfficeSiteAttributeRequest) (response *ModifyOfficeSiteAttributeResponse, err error)

ModifyOfficeSiteAttribute invokes the ecd.ModifyOfficeSiteAttribute API synchronously

func (*Client) ModifyOfficeSiteAttributeWithCallback ¶

func (client *Client) ModifyOfficeSiteAttributeWithCallback(request *ModifyOfficeSiteAttributeRequest, callback func(response *ModifyOfficeSiteAttributeResponse, err error)) <-chan int

ModifyOfficeSiteAttributeWithCallback invokes the ecd.ModifyOfficeSiteAttribute API asynchronously

func (*Client) ModifyOfficeSiteAttributeWithChan ¶

func (client *Client) ModifyOfficeSiteAttributeWithChan(request *ModifyOfficeSiteAttributeRequest) (<-chan *ModifyOfficeSiteAttributeResponse, <-chan error)

ModifyOfficeSiteAttributeWithChan invokes the ecd.ModifyOfficeSiteAttribute API asynchronously

func (*Client) ModifyOfficeSiteCrossDesktopAccess ¶

func (client *Client) ModifyOfficeSiteCrossDesktopAccess(request *ModifyOfficeSiteCrossDesktopAccessRequest) (response *ModifyOfficeSiteCrossDesktopAccessResponse, err error)

ModifyOfficeSiteCrossDesktopAccess invokes the ecd.ModifyOfficeSiteCrossDesktopAccess API synchronously

func (*Client) ModifyOfficeSiteCrossDesktopAccessWithCallback ¶

func (client *Client) ModifyOfficeSiteCrossDesktopAccessWithCallback(request *ModifyOfficeSiteCrossDesktopAccessRequest, callback func(response *ModifyOfficeSiteCrossDesktopAccessResponse, err error)) <-chan int

ModifyOfficeSiteCrossDesktopAccessWithCallback invokes the ecd.ModifyOfficeSiteCrossDesktopAccess API asynchronously

func (*Client) ModifyOfficeSiteCrossDesktopAccessWithChan ¶

func (client *Client) ModifyOfficeSiteCrossDesktopAccessWithChan(request *ModifyOfficeSiteCrossDesktopAccessRequest) (<-chan *ModifyOfficeSiteCrossDesktopAccessResponse, <-chan error)

ModifyOfficeSiteCrossDesktopAccessWithChan invokes the ecd.ModifyOfficeSiteCrossDesktopAccess API asynchronously

func (*Client) ModifyOfficeSiteMfaEnabled ¶

func (client *Client) ModifyOfficeSiteMfaEnabled(request *ModifyOfficeSiteMfaEnabledRequest) (response *ModifyOfficeSiteMfaEnabledResponse, err error)

ModifyOfficeSiteMfaEnabled invokes the ecd.ModifyOfficeSiteMfaEnabled API synchronously

func (*Client) ModifyOfficeSiteMfaEnabledWithCallback ¶

func (client *Client) ModifyOfficeSiteMfaEnabledWithCallback(request *ModifyOfficeSiteMfaEnabledRequest, callback func(response *ModifyOfficeSiteMfaEnabledResponse, err error)) <-chan int

ModifyOfficeSiteMfaEnabledWithCallback invokes the ecd.ModifyOfficeSiteMfaEnabled API asynchronously

func (*Client) ModifyOfficeSiteMfaEnabledWithChan ¶

func (client *Client) ModifyOfficeSiteMfaEnabledWithChan(request *ModifyOfficeSiteMfaEnabledRequest) (<-chan *ModifyOfficeSiteMfaEnabledResponse, <-chan error)

ModifyOfficeSiteMfaEnabledWithChan invokes the ecd.ModifyOfficeSiteMfaEnabled API asynchronously

func (*Client) ModifyOperateVul ¶

func (client *Client) ModifyOperateVul(request *ModifyOperateVulRequest) (response *ModifyOperateVulResponse, err error)

ModifyOperateVul invokes the ecd.ModifyOperateVul API synchronously

func (*Client) ModifyOperateVulWithCallback ¶

func (client *Client) ModifyOperateVulWithCallback(request *ModifyOperateVulRequest, callback func(response *ModifyOperateVulResponse, err error)) <-chan int

ModifyOperateVulWithCallback invokes the ecd.ModifyOperateVul API asynchronously

func (*Client) ModifyOperateVulWithChan ¶

func (client *Client) ModifyOperateVulWithChan(request *ModifyOperateVulRequest) (<-chan *ModifyOperateVulResponse, <-chan error)

ModifyOperateVulWithChan invokes the ecd.ModifyOperateVul API asynchronously

func (*Client) ModifyPolicyGroup ¶

func (client *Client) ModifyPolicyGroup(request *ModifyPolicyGroupRequest) (response *ModifyPolicyGroupResponse, err error)

ModifyPolicyGroup invokes the ecd.ModifyPolicyGroup API synchronously

func (*Client) ModifyPolicyGroupWithCallback ¶

func (client *Client) ModifyPolicyGroupWithCallback(request *ModifyPolicyGroupRequest, callback func(response *ModifyPolicyGroupResponse, err error)) <-chan int

ModifyPolicyGroupWithCallback invokes the ecd.ModifyPolicyGroup API asynchronously

func (*Client) ModifyPolicyGroupWithChan ¶

func (client *Client) ModifyPolicyGroupWithChan(request *ModifyPolicyGroupRequest) (<-chan *ModifyPolicyGroupResponse, <-chan error)

ModifyPolicyGroupWithChan invokes the ecd.ModifyPolicyGroup API asynchronously

func (*Client) ModifyUserEntitlement ¶

func (client *Client) ModifyUserEntitlement(request *ModifyUserEntitlementRequest) (response *ModifyUserEntitlementResponse, err error)

ModifyUserEntitlement invokes the ecd.ModifyUserEntitlement API synchronously

func (*Client) ModifyUserEntitlementWithCallback ¶

func (client *Client) ModifyUserEntitlementWithCallback(request *ModifyUserEntitlementRequest, callback func(response *ModifyUserEntitlementResponse, err error)) <-chan int

ModifyUserEntitlementWithCallback invokes the ecd.ModifyUserEntitlement API asynchronously

func (*Client) ModifyUserEntitlementWithChan ¶

func (client *Client) ModifyUserEntitlementWithChan(request *ModifyUserEntitlementRequest) (<-chan *ModifyUserEntitlementResponse, <-chan error)

ModifyUserEntitlementWithChan invokes the ecd.ModifyUserEntitlement API asynchronously

func (*Client) ModifyUserToDesktopGroup ¶

func (client *Client) ModifyUserToDesktopGroup(request *ModifyUserToDesktopGroupRequest) (response *ModifyUserToDesktopGroupResponse, err error)

ModifyUserToDesktopGroup invokes the ecd.ModifyUserToDesktopGroup API synchronously

func (*Client) ModifyUserToDesktopGroupWithCallback ¶

func (client *Client) ModifyUserToDesktopGroupWithCallback(request *ModifyUserToDesktopGroupRequest, callback func(response *ModifyUserToDesktopGroupResponse, err error)) <-chan int

ModifyUserToDesktopGroupWithCallback invokes the ecd.ModifyUserToDesktopGroup API asynchronously

func (*Client) ModifyUserToDesktopGroupWithChan ¶

func (client *Client) ModifyUserToDesktopGroupWithChan(request *ModifyUserToDesktopGroupRequest) (<-chan *ModifyUserToDesktopGroupResponse, <-chan error)

ModifyUserToDesktopGroupWithChan invokes the ecd.ModifyUserToDesktopGroup API asynchronously

func (*Client) OperateVuls ¶

func (client *Client) OperateVuls(request *OperateVulsRequest) (response *OperateVulsResponse, err error)

OperateVuls invokes the ecd.OperateVuls API synchronously

func (*Client) OperateVulsWithCallback ¶

func (client *Client) OperateVulsWithCallback(request *OperateVulsRequest, callback func(response *OperateVulsResponse, err error)) <-chan int

OperateVulsWithCallback invokes the ecd.OperateVuls API asynchronously

func (*Client) OperateVulsWithChan ¶

func (client *Client) OperateVulsWithChan(request *OperateVulsRequest) (<-chan *OperateVulsResponse, <-chan error)

OperateVulsWithChan invokes the ecd.OperateVuls API asynchronously

func (*Client) RebootDesktops ¶

func (client *Client) RebootDesktops(request *RebootDesktopsRequest) (response *RebootDesktopsResponse, err error)

RebootDesktops invokes the ecd.RebootDesktops API synchronously

func (*Client) RebootDesktopsWithCallback ¶

func (client *Client) RebootDesktopsWithCallback(request *RebootDesktopsRequest, callback func(response *RebootDesktopsResponse, err error)) <-chan int

RebootDesktopsWithCallback invokes the ecd.RebootDesktops API asynchronously

func (*Client) RebootDesktopsWithChan ¶

func (client *Client) RebootDesktopsWithChan(request *RebootDesktopsRequest) (<-chan *RebootDesktopsResponse, <-chan error)

RebootDesktopsWithChan invokes the ecd.RebootDesktops API asynchronously

func (*Client) RebuildDesktops ¶

func (client *Client) RebuildDesktops(request *RebuildDesktopsRequest) (response *RebuildDesktopsResponse, err error)

RebuildDesktops invokes the ecd.RebuildDesktops API synchronously

func (*Client) RebuildDesktopsWithCallback ¶

func (client *Client) RebuildDesktopsWithCallback(request *RebuildDesktopsRequest, callback func(response *RebuildDesktopsResponse, err error)) <-chan int

RebuildDesktopsWithCallback invokes the ecd.RebuildDesktops API asynchronously

func (*Client) RebuildDesktopsWithChan ¶

func (client *Client) RebuildDesktopsWithChan(request *RebuildDesktopsRequest) (<-chan *RebuildDesktopsResponse, <-chan error)

RebuildDesktopsWithChan invokes the ecd.RebuildDesktops API asynchronously

func (*Client) RemoveUserFromDesktopGroup ¶

func (client *Client) RemoveUserFromDesktopGroup(request *RemoveUserFromDesktopGroupRequest) (response *RemoveUserFromDesktopGroupResponse, err error)

RemoveUserFromDesktopGroup invokes the ecd.RemoveUserFromDesktopGroup API synchronously

func (*Client) RemoveUserFromDesktopGroupWithCallback ¶

func (client *Client) RemoveUserFromDesktopGroupWithCallback(request *RemoveUserFromDesktopGroupRequest, callback func(response *RemoveUserFromDesktopGroupResponse, err error)) <-chan int

RemoveUserFromDesktopGroupWithCallback invokes the ecd.RemoveUserFromDesktopGroup API asynchronously

func (*Client) RemoveUserFromDesktopGroupWithChan ¶

func (client *Client) RemoveUserFromDesktopGroupWithChan(request *RemoveUserFromDesktopGroupRequest) (<-chan *RemoveUserFromDesktopGroupResponse, <-chan error)

RemoveUserFromDesktopGroupWithChan invokes the ecd.RemoveUserFromDesktopGroup API asynchronously

func (*Client) RenewDesktops ¶

func (client *Client) RenewDesktops(request *RenewDesktopsRequest) (response *RenewDesktopsResponse, err error)

RenewDesktops invokes the ecd.RenewDesktops API synchronously

func (*Client) RenewDesktopsWithCallback ¶

func (client *Client) RenewDesktopsWithCallback(request *RenewDesktopsRequest, callback func(response *RenewDesktopsResponse, err error)) <-chan int

RenewDesktopsWithCallback invokes the ecd.RenewDesktops API asynchronously

func (*Client) RenewDesktopsWithChan ¶

func (client *Client) RenewDesktopsWithChan(request *RenewDesktopsRequest) (<-chan *RenewDesktopsResponse, <-chan error)

RenewDesktopsWithChan invokes the ecd.RenewDesktops API asynchronously

func (*Client) RenewNetworkPackages ¶

func (client *Client) RenewNetworkPackages(request *RenewNetworkPackagesRequest) (response *RenewNetworkPackagesResponse, err error)

RenewNetworkPackages invokes the ecd.RenewNetworkPackages API synchronously

func (*Client) RenewNetworkPackagesWithCallback ¶

func (client *Client) RenewNetworkPackagesWithCallback(request *RenewNetworkPackagesRequest, callback func(response *RenewNetworkPackagesResponse, err error)) <-chan int

RenewNetworkPackagesWithCallback invokes the ecd.RenewNetworkPackages API asynchronously

func (*Client) RenewNetworkPackagesWithChan ¶

func (client *Client) RenewNetworkPackagesWithChan(request *RenewNetworkPackagesRequest) (<-chan *RenewNetworkPackagesResponse, <-chan error)

RenewNetworkPackagesWithChan invokes the ecd.RenewNetworkPackages API asynchronously

func (*Client) ResetDesktops ¶

func (client *Client) ResetDesktops(request *ResetDesktopsRequest) (response *ResetDesktopsResponse, err error)

ResetDesktops invokes the ecd.ResetDesktops API synchronously

func (*Client) ResetDesktopsWithCallback ¶

func (client *Client) ResetDesktopsWithCallback(request *ResetDesktopsRequest, callback func(response *ResetDesktopsResponse, err error)) <-chan int

ResetDesktopsWithCallback invokes the ecd.ResetDesktops API asynchronously

func (*Client) ResetDesktopsWithChan ¶

func (client *Client) ResetDesktopsWithChan(request *ResetDesktopsRequest) (<-chan *ResetDesktopsResponse, <-chan error)

ResetDesktopsWithChan invokes the ecd.ResetDesktops API asynchronously

func (*Client) ResetNASDefaultMountTarget ¶

func (client *Client) ResetNASDefaultMountTarget(request *ResetNASDefaultMountTargetRequest) (response *ResetNASDefaultMountTargetResponse, err error)

ResetNASDefaultMountTarget invokes the ecd.ResetNASDefaultMountTarget API synchronously

func (*Client) ResetNASDefaultMountTargetWithCallback ¶

func (client *Client) ResetNASDefaultMountTargetWithCallback(request *ResetNASDefaultMountTargetRequest, callback func(response *ResetNASDefaultMountTargetResponse, err error)) <-chan int

ResetNASDefaultMountTargetWithCallback invokes the ecd.ResetNASDefaultMountTarget API asynchronously

func (*Client) ResetNASDefaultMountTargetWithChan ¶

func (client *Client) ResetNASDefaultMountTargetWithChan(request *ResetNASDefaultMountTargetRequest) (<-chan *ResetNASDefaultMountTargetResponse, <-chan error)

ResetNASDefaultMountTargetWithChan invokes the ecd.ResetNASDefaultMountTarget API asynchronously

func (*Client) ResetSnapshot ¶

func (client *Client) ResetSnapshot(request *ResetSnapshotRequest) (response *ResetSnapshotResponse, err error)

ResetSnapshot invokes the ecd.ResetSnapshot API synchronously

func (*Client) ResetSnapshotWithCallback ¶

func (client *Client) ResetSnapshotWithCallback(request *ResetSnapshotRequest, callback func(response *ResetSnapshotResponse, err error)) <-chan int

ResetSnapshotWithCallback invokes the ecd.ResetSnapshot API asynchronously

func (*Client) ResetSnapshotWithChan ¶

func (client *Client) ResetSnapshotWithChan(request *ResetSnapshotRequest) (<-chan *ResetSnapshotResponse, <-chan error)

ResetSnapshotWithChan invokes the ecd.ResetSnapshot API asynchronously

func (*Client) RollbackSuspEventQuaraFile ¶

func (client *Client) RollbackSuspEventQuaraFile(request *RollbackSuspEventQuaraFileRequest) (response *RollbackSuspEventQuaraFileResponse, err error)

RollbackSuspEventQuaraFile invokes the ecd.RollbackSuspEventQuaraFile API synchronously

func (*Client) RollbackSuspEventQuaraFileWithCallback ¶

func (client *Client) RollbackSuspEventQuaraFileWithCallback(request *RollbackSuspEventQuaraFileRequest, callback func(response *RollbackSuspEventQuaraFileResponse, err error)) <-chan int

RollbackSuspEventQuaraFileWithCallback invokes the ecd.RollbackSuspEventQuaraFile API asynchronously

func (*Client) RollbackSuspEventQuaraFileWithChan ¶

func (client *Client) RollbackSuspEventQuaraFileWithChan(request *RollbackSuspEventQuaraFileRequest) (<-chan *RollbackSuspEventQuaraFileResponse, <-chan error)

RollbackSuspEventQuaraFileWithChan invokes the ecd.RollbackSuspEventQuaraFile API asynchronously

func (*Client) RunCommand ¶

func (client *Client) RunCommand(request *RunCommandRequest) (response *RunCommandResponse, err error)

RunCommand invokes the ecd.RunCommand API synchronously

func (*Client) RunCommandWithCallback ¶

func (client *Client) RunCommandWithCallback(request *RunCommandRequest, callback func(response *RunCommandResponse, err error)) <-chan int

RunCommandWithCallback invokes the ecd.RunCommand API asynchronously

func (*Client) RunCommandWithChan ¶

func (client *Client) RunCommandWithChan(request *RunCommandRequest) (<-chan *RunCommandResponse, <-chan error)

RunCommandWithChan invokes the ecd.RunCommand API asynchronously

func (*Client) SendVerifyCode ¶

func (client *Client) SendVerifyCode(request *SendVerifyCodeRequest) (response *SendVerifyCodeResponse, err error)

SendVerifyCode invokes the ecd.SendVerifyCode API synchronously

func (*Client) SendVerifyCodeWithCallback ¶

func (client *Client) SendVerifyCodeWithCallback(request *SendVerifyCodeRequest, callback func(response *SendVerifyCodeResponse, err error)) <-chan int

SendVerifyCodeWithCallback invokes the ecd.SendVerifyCode API asynchronously

func (*Client) SendVerifyCodeWithChan ¶

func (client *Client) SendVerifyCodeWithChan(request *SendVerifyCodeRequest) (<-chan *SendVerifyCodeResponse, <-chan error)

SendVerifyCodeWithChan invokes the ecd.SendVerifyCode API asynchronously

func (*Client) SetDirectorySsoStatus ¶

func (client *Client) SetDirectorySsoStatus(request *SetDirectorySsoStatusRequest) (response *SetDirectorySsoStatusResponse, err error)

SetDirectorySsoStatus invokes the ecd.SetDirectorySsoStatus API synchronously

func (*Client) SetDirectorySsoStatusWithCallback ¶

func (client *Client) SetDirectorySsoStatusWithCallback(request *SetDirectorySsoStatusRequest, callback func(response *SetDirectorySsoStatusResponse, err error)) <-chan int

SetDirectorySsoStatusWithCallback invokes the ecd.SetDirectorySsoStatus API asynchronously

func (*Client) SetDirectorySsoStatusWithChan ¶

func (client *Client) SetDirectorySsoStatusWithChan(request *SetDirectorySsoStatusRequest) (<-chan *SetDirectorySsoStatusResponse, <-chan error)

SetDirectorySsoStatusWithChan invokes the ecd.SetDirectorySsoStatus API asynchronously

func (*Client) SetIdpMetadata ¶

func (client *Client) SetIdpMetadata(request *SetIdpMetadataRequest) (response *SetIdpMetadataResponse, err error)

SetIdpMetadata invokes the ecd.SetIdpMetadata API synchronously

func (*Client) SetIdpMetadataWithCallback ¶

func (client *Client) SetIdpMetadataWithCallback(request *SetIdpMetadataRequest, callback func(response *SetIdpMetadataResponse, err error)) <-chan int

SetIdpMetadataWithCallback invokes the ecd.SetIdpMetadata API asynchronously

func (*Client) SetIdpMetadataWithChan ¶

func (client *Client) SetIdpMetadataWithChan(request *SetIdpMetadataRequest) (<-chan *SetIdpMetadataResponse, <-chan error)

SetIdpMetadataWithChan invokes the ecd.SetIdpMetadata API asynchronously

func (*Client) SetOfficeSiteSsoStatus ¶

func (client *Client) SetOfficeSiteSsoStatus(request *SetOfficeSiteSsoStatusRequest) (response *SetOfficeSiteSsoStatusResponse, err error)

SetOfficeSiteSsoStatus invokes the ecd.SetOfficeSiteSsoStatus API synchronously

func (*Client) SetOfficeSiteSsoStatusWithCallback ¶

func (client *Client) SetOfficeSiteSsoStatusWithCallback(request *SetOfficeSiteSsoStatusRequest, callback func(response *SetOfficeSiteSsoStatusResponse, err error)) <-chan int

SetOfficeSiteSsoStatusWithCallback invokes the ecd.SetOfficeSiteSsoStatus API asynchronously

func (*Client) SetOfficeSiteSsoStatusWithChan ¶

func (client *Client) SetOfficeSiteSsoStatusWithChan(request *SetOfficeSiteSsoStatusRequest) (<-chan *SetOfficeSiteSsoStatusResponse, <-chan error)

SetOfficeSiteSsoStatusWithChan invokes the ecd.SetOfficeSiteSsoStatus API asynchronously

func (*Client) StartDesktops ¶

func (client *Client) StartDesktops(request *StartDesktopsRequest) (response *StartDesktopsResponse, err error)

StartDesktops invokes the ecd.StartDesktops API synchronously

func (*Client) StartDesktopsWithCallback ¶

func (client *Client) StartDesktopsWithCallback(request *StartDesktopsRequest, callback func(response *StartDesktopsResponse, err error)) <-chan int

StartDesktopsWithCallback invokes the ecd.StartDesktops API asynchronously

func (*Client) StartDesktopsWithChan ¶

func (client *Client) StartDesktopsWithChan(request *StartDesktopsRequest) (<-chan *StartDesktopsResponse, <-chan error)

StartDesktopsWithChan invokes the ecd.StartDesktops API asynchronously

func (*Client) StartVirusScanTask ¶

func (client *Client) StartVirusScanTask(request *StartVirusScanTaskRequest) (response *StartVirusScanTaskResponse, err error)

StartVirusScanTask invokes the ecd.StartVirusScanTask API synchronously

func (*Client) StartVirusScanTaskWithCallback ¶

func (client *Client) StartVirusScanTaskWithCallback(request *StartVirusScanTaskRequest, callback func(response *StartVirusScanTaskResponse, err error)) <-chan int

StartVirusScanTaskWithCallback invokes the ecd.StartVirusScanTask API asynchronously

func (*Client) StartVirusScanTaskWithChan ¶

func (client *Client) StartVirusScanTaskWithChan(request *StartVirusScanTaskRequest) (<-chan *StartVirusScanTaskResponse, <-chan error)

StartVirusScanTaskWithChan invokes the ecd.StartVirusScanTask API asynchronously

func (*Client) StopDesktops ¶

func (client *Client) StopDesktops(request *StopDesktopsRequest) (response *StopDesktopsResponse, err error)

StopDesktops invokes the ecd.StopDesktops API synchronously

func (*Client) StopDesktopsWithCallback ¶

func (client *Client) StopDesktopsWithCallback(request *StopDesktopsRequest, callback func(response *StopDesktopsResponse, err error)) <-chan int

StopDesktopsWithCallback invokes the ecd.StopDesktops API asynchronously

func (*Client) StopDesktopsWithChan ¶

func (client *Client) StopDesktopsWithChan(request *StopDesktopsRequest) (<-chan *StopDesktopsResponse, <-chan error)

StopDesktopsWithChan invokes the ecd.StopDesktops API asynchronously

func (*Client) StopInvocation ¶

func (client *Client) StopInvocation(request *StopInvocationRequest) (response *StopInvocationResponse, err error)

StopInvocation invokes the ecd.StopInvocation API synchronously

func (*Client) StopInvocationWithCallback ¶

func (client *Client) StopInvocationWithCallback(request *StopInvocationRequest, callback func(response *StopInvocationResponse, err error)) <-chan int

StopInvocationWithCallback invokes the ecd.StopInvocation API asynchronously

func (*Client) StopInvocationWithChan ¶

func (client *Client) StopInvocationWithChan(request *StopInvocationRequest) (<-chan *StopInvocationResponse, <-chan error)

StopInvocationWithChan invokes the ecd.StopInvocation API asynchronously

func (*Client) TagResources ¶

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

TagResources invokes the ecd.TagResources API synchronously

func (*Client) TagResourcesWithCallback ¶

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

TagResourcesWithCallback invokes the ecd.TagResources API asynchronously

func (*Client) TagResourcesWithChan ¶

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

TagResourcesWithChan invokes the ecd.TagResources API asynchronously

func (*Client) UnlockVirtualMFADevice ¶

func (client *Client) UnlockVirtualMFADevice(request *UnlockVirtualMFADeviceRequest) (response *UnlockVirtualMFADeviceResponse, err error)

UnlockVirtualMFADevice invokes the ecd.UnlockVirtualMFADevice API synchronously

func (*Client) UnlockVirtualMFADeviceWithCallback ¶

func (client *Client) UnlockVirtualMFADeviceWithCallback(request *UnlockVirtualMFADeviceRequest, callback func(response *UnlockVirtualMFADeviceResponse, err error)) <-chan int

UnlockVirtualMFADeviceWithCallback invokes the ecd.UnlockVirtualMFADevice API asynchronously

func (*Client) UnlockVirtualMFADeviceWithChan ¶

func (client *Client) UnlockVirtualMFADeviceWithChan(request *UnlockVirtualMFADeviceRequest) (<-chan *UnlockVirtualMFADeviceResponse, <-chan error)

UnlockVirtualMFADeviceWithChan invokes the ecd.UnlockVirtualMFADevice API asynchronously

func (*Client) UntagResources ¶

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

UntagResources invokes the ecd.UntagResources API synchronously

func (*Client) UntagResourcesWithCallback ¶

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

UntagResourcesWithCallback invokes the ecd.UntagResources API asynchronously

func (*Client) UntagResourcesWithChan ¶

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

UntagResourcesWithChan invokes the ecd.UntagResources API asynchronously

func (*Client) UpdateFotaTask ¶

func (client *Client) UpdateFotaTask(request *UpdateFotaTaskRequest) (response *UpdateFotaTaskResponse, err error)

UpdateFotaTask invokes the ecd.UpdateFotaTask API synchronously

func (*Client) UpdateFotaTaskWithCallback ¶

func (client *Client) UpdateFotaTaskWithCallback(request *UpdateFotaTaskRequest, callback func(response *UpdateFotaTaskResponse, err error)) <-chan int

UpdateFotaTaskWithCallback invokes the ecd.UpdateFotaTask API asynchronously

func (*Client) UpdateFotaTaskWithChan ¶

func (client *Client) UpdateFotaTaskWithChan(request *UpdateFotaTaskRequest) (<-chan *UpdateFotaTaskResponse, <-chan error)

UpdateFotaTaskWithChan invokes the ecd.UpdateFotaTask API asynchronously

func (*Client) UploadImage ¶

func (client *Client) UploadImage(request *UploadImageRequest) (response *UploadImageResponse, err error)

UploadImage invokes the ecd.UploadImage API synchronously

func (*Client) UploadImageWithCallback ¶

func (client *Client) UploadImageWithCallback(request *UploadImageRequest, callback func(response *UploadImageResponse, err error)) <-chan int

UploadImageWithCallback invokes the ecd.UploadImage API asynchronously

func (*Client) UploadImageWithChan ¶

func (client *Client) UploadImageWithChan(request *UploadImageRequest) (<-chan *UploadImageResponse, <-chan error)

UploadImageWithChan invokes the ecd.UploadImage API asynchronously

func (*Client) VerifyCen ¶

func (client *Client) VerifyCen(request *VerifyCenRequest) (response *VerifyCenResponse, err error)

VerifyCen invokes the ecd.VerifyCen API synchronously

func (*Client) VerifyCenWithCallback ¶

func (client *Client) VerifyCenWithCallback(request *VerifyCenRequest, callback func(response *VerifyCenResponse, err error)) <-chan int

VerifyCenWithCallback invokes the ecd.VerifyCen API asynchronously

func (*Client) VerifyCenWithChan ¶

func (client *Client) VerifyCenWithChan(request *VerifyCenRequest) (<-chan *VerifyCenResponse, <-chan error)

VerifyCenWithChan invokes the ecd.VerifyCen API asynchronously

type ClientType ¶

type ClientType struct {
	Status     string `json:"Status" xml:"Status"`
	ClientType string `json:"ClientType" xml:"ClientType"`
}

ClientType is a nested struct in ecd response

type ClientTypes ¶

type ClientTypes struct {
	ClientType []ClientType `json:"ClientType" xml:"ClientType"`
}

ClientTypes is a nested struct in ecd response

type ClonePolicyGroupRequest ¶

type ClonePolicyGroupRequest struct {
	*requests.RpcRequest
	Name          string `position:"Query" name:"Name"`
	PolicyGroupId string `position:"Query" name:"PolicyGroupId"`
}

ClonePolicyGroupRequest is the request struct for api ClonePolicyGroup

func CreateClonePolicyGroupRequest ¶

func CreateClonePolicyGroupRequest() (request *ClonePolicyGroupRequest)

CreateClonePolicyGroupRequest creates a request to invoke ClonePolicyGroup API

type ClonePolicyGroupResponse ¶

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

ClonePolicyGroupResponse is the response struct for api ClonePolicyGroup

func CreateClonePolicyGroupResponse ¶

func CreateClonePolicyGroupResponse() (response *ClonePolicyGroupResponse)

CreateClonePolicyGroupResponse creates a response to parse from ClonePolicyGroup response

type ConfigADConnectorTrustRequest ¶

type ConfigADConnectorTrustRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
	TrustKey     string `position:"Query" name:"TrustKey"`
}

ConfigADConnectorTrustRequest is the request struct for api ConfigADConnectorTrust

func CreateConfigADConnectorTrustRequest ¶

func CreateConfigADConnectorTrustRequest() (request *ConfigADConnectorTrustRequest)

CreateConfigADConnectorTrustRequest creates a request to invoke ConfigADConnectorTrust API

type ConfigADConnectorTrustResponse ¶

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

ConfigADConnectorTrustResponse is the response struct for api ConfigADConnectorTrust

func CreateConfigADConnectorTrustResponse ¶

func CreateConfigADConnectorTrustResponse() (response *ConfigADConnectorTrustResponse)

CreateConfigADConnectorTrustResponse creates a response to parse from ConfigADConnectorTrust response

type ConfigADConnectorUserRequest ¶

type ConfigADConnectorUserRequest struct {
	*requests.RpcRequest
	OfficeSiteId   string `position:"Query" name:"OfficeSiteId"`
	DomainPassword string `position:"Query" name:"DomainPassword"`
	DomainUserName string `position:"Query" name:"DomainUserName"`
	OUName         string `position:"Query" name:"OUName"`
}

ConfigADConnectorUserRequest is the request struct for api ConfigADConnectorUser

func CreateConfigADConnectorUserRequest ¶

func CreateConfigADConnectorUserRequest() (request *ConfigADConnectorUserRequest)

CreateConfigADConnectorUserRequest creates a request to invoke ConfigADConnectorUser API

type ConfigADConnectorUserResponse ¶

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

ConfigADConnectorUserResponse is the response struct for api ConfigADConnectorUser

func CreateConfigADConnectorUserResponse ¶

func CreateConfigADConnectorUserResponse() (response *ConfigADConnectorUserResponse)

CreateConfigADConnectorUserResponse creates a response to parse from ConfigADConnectorUser response

type ConnectionRecord ¶

type ConnectionRecord struct {
	ConnectionRecordId string `json:"ConnectionRecordId" xml:"ConnectionRecordId"`
	ConnectStartTime   string `json:"ConnectStartTime" xml:"ConnectStartTime"`
	DesktopName        string `json:"DesktopName" xml:"DesktopName"`
	ConnectDuration    string `json:"ConnectDuration" xml:"ConnectDuration"`
	ConnectEndTime     string `json:"ConnectEndTime" xml:"ConnectEndTime"`
	DesktopId          string `json:"DesktopId" xml:"DesktopId"`
}

ConnectionRecord is a nested struct in ecd response

type ConnectionRecords ¶

type ConnectionRecords struct {
	ConnectionRecord []ConnectionRecord `json:"ConnectionRecord" xml:"ConnectionRecord"`
}

ConnectionRecords is a nested struct in ecd response

type CoordinateFlowModel ¶

type CoordinateFlowModel struct {
	CoordinateStatus string `json:"CoordinateStatus" xml:"CoordinateStatus"`
	InitiatorType    string `json:"InitiatorType" xml:"InitiatorType"`
	OwnerUserId      string `json:"OwnerUserId" xml:"OwnerUserId"`
	CoordinateTicket string `json:"CoordinateTicket" xml:"CoordinateTicket"`
	CoId             string `json:"CoId" xml:"CoId"`
	ResourceId       string `json:"ResourceId" xml:"ResourceId"`
	ResourceName     string `json:"ResourceName" xml:"ResourceName"`
}

CoordinateFlowModel is a nested struct in ecd response

type CoordinateFlowModels ¶

type CoordinateFlowModels struct {
	CoordinateFlowModel []CoordinateFlowModel `json:"CoordinateFlowModel" xml:"CoordinateFlowModel"`
}

CoordinateFlowModels is a nested struct in ecd response

type CopyImageRequest ¶

type CopyImageRequest struct {
	*requests.RpcRequest
	ImageId                string `position:"Query" name:"ImageId"`
	DestinationImageName   string `position:"Query" name:"DestinationImageName"`
	DestinationRegionId    string `position:"Query" name:"DestinationRegionId"`
	DestinationDescription string `position:"Query" name:"DestinationDescription"`
}

CopyImageRequest is the request struct for api CopyImage

func CreateCopyImageRequest ¶

func CreateCopyImageRequest() (request *CopyImageRequest)

CreateCopyImageRequest creates a request to invoke CopyImage API

type CopyImageResponse ¶

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

CopyImageResponse is the response struct for api CopyImage

func CreateCopyImageResponse ¶

func CreateCopyImageResponse() (response *CopyImageResponse)

CreateCopyImageResponse creates a response to parse from CopyImage response

type CreateADConnectorDirectoryRequest ¶

type CreateADConnectorDirectoryRequest struct {
	*requests.RpcRequest
	SubDomainDnsAddress *[]string        `position:"Query" name:"SubDomainDnsAddress"  type:"Repeated"`
	SubDomainName       string           `position:"Query" name:"SubDomainName"`
	DomainPassword      string           `position:"Query" name:"DomainPassword"`
	EnableAdminAccess   requests.Boolean `position:"Query" name:"EnableAdminAccess"`
	DesktopAccessType   string           `position:"Query" name:"DesktopAccessType"`
	DomainName          string           `position:"Query" name:"DomainName"`
	Specification       requests.Integer `position:"Query" name:"Specification"`
	DirectoryName       string           `position:"Query" name:"DirectoryName"`
	VSwitchId           *[]string        `position:"Query" name:"VSwitchId"  type:"Repeated"`
	MfaEnabled          requests.Boolean `position:"Query" name:"MfaEnabled"`
	DomainUserName      string           `position:"Query" name:"DomainUserName"`
	DnsAddress          *[]string        `position:"Query" name:"DnsAddress"  type:"Repeated"`
}

CreateADConnectorDirectoryRequest is the request struct for api CreateADConnectorDirectory

func CreateCreateADConnectorDirectoryRequest ¶

func CreateCreateADConnectorDirectoryRequest() (request *CreateADConnectorDirectoryRequest)

CreateCreateADConnectorDirectoryRequest creates a request to invoke CreateADConnectorDirectory API

type CreateADConnectorDirectoryResponse ¶

type CreateADConnectorDirectoryResponse struct {
	*responses.BaseResponse
	TrustPassword string        `json:"TrustPassword" xml:"TrustPassword"`
	RequestId     string        `json:"RequestId" xml:"RequestId"`
	DirectoryId   string        `json:"DirectoryId" xml:"DirectoryId"`
	AdConnectors  []AdConnector `json:"AdConnectors" xml:"AdConnectors"`
}

CreateADConnectorDirectoryResponse is the response struct for api CreateADConnectorDirectory

func CreateCreateADConnectorDirectoryResponse ¶

func CreateCreateADConnectorDirectoryResponse() (response *CreateADConnectorDirectoryResponse)

CreateCreateADConnectorDirectoryResponse creates a response to parse from CreateADConnectorDirectory response

type CreateADConnectorOfficeSiteRequest ¶

type CreateADConnectorOfficeSiteRequest struct {
	*requests.RpcRequest
	CenId                string           `position:"Query" name:"CenId"`
	SubDomainDnsAddress  *[]string        `position:"Query" name:"SubDomainDnsAddress"  type:"Repeated"`
	CenOwnerId           requests.Integer `position:"Query" name:"CenOwnerId"`
	EnableInternetAccess requests.Boolean `position:"Query" name:"EnableInternetAccess"`
	SubDomainName        string           `position:"Query" name:"SubDomainName"`
	DomainPassword       string           `position:"Query" name:"DomainPassword"`
	VerifyCode           string           `position:"Query" name:"VerifyCode"`
	EnableAdminAccess    requests.Boolean `position:"Query" name:"EnableAdminAccess"`
	Bandwidth            requests.Integer `position:"Query" name:"Bandwidth"`
	DesktopAccessType    string           `position:"Query" name:"DesktopAccessType"`
	AdHostname           string           `position:"Query" name:"AdHostname"`
	DomainName           string           `position:"Query" name:"DomainName"`
	Specification        requests.Integer `position:"Query" name:"Specification"`
	OfficeSiteName       string           `position:"Query" name:"OfficeSiteName"`
	MfaEnabled           requests.Boolean `position:"Query" name:"MfaEnabled"`
	DomainUserName       string           `position:"Query" name:"DomainUserName"`
	CidrBlock            string           `position:"Query" name:"CidrBlock"`
	ProtocolType         string           `position:"Query" name:"ProtocolType"`
	DnsAddress           *[]string        `position:"Query" name:"DnsAddress"  type:"Repeated"`
}

CreateADConnectorOfficeSiteRequest is the request struct for api CreateADConnectorOfficeSite

func CreateCreateADConnectorOfficeSiteRequest ¶

func CreateCreateADConnectorOfficeSiteRequest() (request *CreateADConnectorOfficeSiteRequest)

CreateCreateADConnectorOfficeSiteRequest creates a request to invoke CreateADConnectorOfficeSite API

type CreateADConnectorOfficeSiteResponse ¶

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

CreateADConnectorOfficeSiteResponse is the response struct for api CreateADConnectorOfficeSite

func CreateCreateADConnectorOfficeSiteResponse ¶

func CreateCreateADConnectorOfficeSiteResponse() (response *CreateADConnectorOfficeSiteResponse)

CreateCreateADConnectorOfficeSiteResponse creates a response to parse from CreateADConnectorOfficeSite response

type CreateBundleRequest ¶

type CreateBundleRequest struct {
	*requests.RpcRequest
	RootDiskPerformanceLevel string           `position:"Query" name:"RootDiskPerformanceLevel"`
	ImageId                  string           `position:"Query" name:"ImageId"`
	Description              string           `position:"Query" name:"Description"`
	Language                 string           `position:"Query" name:"Language"`
	UserDiskPerformanceLevel string           `position:"Query" name:"UserDiskPerformanceLevel"`
	DesktopType              string           `position:"Query" name:"DesktopType"`
	BundleName               string           `position:"Query" name:"BundleName"`
	UserDiskSizeGib          *[]string        `position:"Query" name:"UserDiskSizeGib"  type:"Repeated"`
	RootDiskSizeGib          requests.Integer `position:"Query" name:"RootDiskSizeGib"`
}

CreateBundleRequest is the request struct for api CreateBundle

func CreateCreateBundleRequest ¶

func CreateCreateBundleRequest() (request *CreateBundleRequest)

CreateCreateBundleRequest creates a request to invoke CreateBundle API

type CreateBundleResponse ¶

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

CreateBundleResponse is the response struct for api CreateBundle

func CreateCreateBundleResponse ¶

func CreateCreateBundleResponse() (response *CreateBundleResponse)

CreateCreateBundleResponse creates a response to parse from CreateBundle response

type CreateDesktopGroupRequest ¶

type CreateDesktopGroupRequest struct {
	*requests.RpcRequest
	VolumeEncryptionKey     string           `position:"Query" name:"VolumeEncryptionKey"`
	OfficeSiteId            string           `position:"Query" name:"OfficeSiteId"`
	Classify                string           `position:"Query" name:"Classify"`
	EndUserIds              *[]string        `position:"Query" name:"EndUserIds"  type:"Repeated"`
	ScaleStrategyId         string           `position:"Query" name:"ScaleStrategyId"`
	ClientToken             string           `position:"Query" name:"ClientToken"`
	BundleId                string           `position:"Query" name:"BundleId"`
	BindAmount              requests.Integer `position:"Query" name:"BindAmount"`
	LoadPolicy              requests.Integer `position:"Query" name:"LoadPolicy"`
	DesktopGroupName        string           `position:"Query" name:"DesktopGroupName"`
	AllowBufferCount        requests.Integer `position:"Query" name:"AllowBufferCount"`
	DefaultInitDesktopCount requests.Integer `position:"Query" name:"DefaultInitDesktopCount"`
	DirectoryId             string           `position:"Query" name:"DirectoryId"`
	MinDesktopsCount        requests.Integer `position:"Query" name:"MinDesktopsCount"`
	AllClassifyUsers        requests.Boolean `position:"Query" name:"AllClassifyUsers"`
	MaxDesktopsCount        requests.Integer `position:"Query" name:"MaxDesktopsCount"`
	VolumeEncryptionEnabled requests.Boolean `position:"Query" name:"VolumeEncryptionEnabled"`
	Period                  requests.Integer `position:"Query" name:"Period"`
	AllowAutoSetup          requests.Integer `position:"Query" name:"AllowAutoSetup"`
	AutoPay                 requests.Boolean `position:"Query" name:"AutoPay"`
	Comments                string           `position:"Query" name:"Comments"`
	ResetType               requests.Integer `position:"Query" name:"ResetType"`
	OwnType                 requests.Integer `position:"Query" name:"OwnType"`
	KeepDuration            requests.Integer `position:"Query" name:"KeepDuration"`
	PeriodUnit              string           `position:"Query" name:"PeriodUnit"`
	VpcId                   string           `position:"Query" name:"VpcId"`
	ChargeType              string           `position:"Query" name:"ChargeType"`
	PolicyGroupId           string           `position:"Query" name:"PolicyGroupId"`
}

CreateDesktopGroupRequest is the request struct for api CreateDesktopGroup

func CreateCreateDesktopGroupRequest ¶

func CreateCreateDesktopGroupRequest() (request *CreateDesktopGroupRequest)

CreateCreateDesktopGroupRequest creates a request to invoke CreateDesktopGroup API

type CreateDesktopGroupResponse ¶

type CreateDesktopGroupResponse struct {
	*responses.BaseResponse
	DesktopGroupId string   `json:"DesktopGroupId" xml:"DesktopGroupId"`
	RequestId      string   `json:"RequestId" xml:"RequestId"`
	OrderIds       []string `json:"OrderIds" xml:"OrderIds"`
}

CreateDesktopGroupResponse is the response struct for api CreateDesktopGroup

func CreateCreateDesktopGroupResponse ¶

func CreateCreateDesktopGroupResponse() (response *CreateDesktopGroupResponse)

CreateCreateDesktopGroupResponse creates a response to parse from CreateDesktopGroup response

type CreateDesktopsRequest ¶

type CreateDesktopsRequest struct {
	*requests.RpcRequest
	VolumeEncryptionKey     string               `position:"Query" name:"VolumeEncryptionKey"`
	OfficeSiteId            string               `position:"Query" name:"OfficeSiteId"`
	ImageId                 string               `position:"Query" name:"ImageId"`
	BundleId                string               `position:"Query" name:"BundleId"`
	UserAssignMode          string               `position:"Query" name:"UserAssignMode"`
	Hostname                string               `position:"Query" name:"Hostname"`
	DesktopNameSuffix       requests.Boolean     `position:"Query" name:"DesktopNameSuffix"`
	SystemDiskSize          string               `position:"Query" name:"SystemDiskSize"`
	DirectoryId             string               `position:"Query" name:"DirectoryId"`
	EndUserId               *[]string            `position:"Query" name:"EndUserId"  type:"Repeated"`
	Tag                     *[]CreateDesktopsTag `position:"Query" name:"Tag"  type:"Repeated"`
	VolumeEncryptionEnabled requests.Boolean     `position:"Query" name:"VolumeEncryptionEnabled"`
	DesktopName             string               `position:"Query" name:"DesktopName"`
	Amount                  requests.Integer     `position:"Query" name:"Amount"`
	Period                  requests.Integer     `position:"Query" name:"Period"`
	AutoPay                 requests.Boolean     `position:"Query" name:"AutoPay"`
	GroupId                 string               `position:"Query" name:"GroupId"`
	EcsInstanceType         string               `position:"Query" name:"EcsInstanceType"`
	PromotionId             string               `position:"Query" name:"PromotionId"`
	PeriodUnit              string               `position:"Query" name:"PeriodUnit"`
	AutoRenew               requests.Boolean     `position:"Query" name:"AutoRenew"`
	DataDiskSize            string               `position:"Query" name:"DataDiskSize"`
	VpcId                   string               `position:"Query" name:"VpcId"`
	ChargeType              string               `position:"Query" name:"ChargeType"`
	PolicyGroupId           string               `position:"Query" name:"PolicyGroupId"`
	UserName                string               `position:"Query" name:"UserName"`
}

CreateDesktopsRequest is the request struct for api CreateDesktops

func CreateCreateDesktopsRequest ¶

func CreateCreateDesktopsRequest() (request *CreateDesktopsRequest)

CreateCreateDesktopsRequest creates a request to invoke CreateDesktops API

type CreateDesktopsResponse ¶

type CreateDesktopsResponse struct {
	*responses.BaseResponse
	OrderId   string   `json:"OrderId" xml:"OrderId"`
	RequestId string   `json:"RequestId" xml:"RequestId"`
	DesktopId []string `json:"DesktopId" xml:"DesktopId"`
}

CreateDesktopsResponse is the response struct for api CreateDesktops

func CreateCreateDesktopsResponse ¶

func CreateCreateDesktopsResponse() (response *CreateDesktopsResponse)

CreateCreateDesktopsResponse creates a response to parse from CreateDesktops response

type CreateDesktopsTag ¶

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

CreateDesktopsTag is a repeated param struct in CreateDesktopsRequest

type CreateDiskEncryptionServiceRequest ¶

type CreateDiskEncryptionServiceRequest struct {
	*requests.RpcRequest
}

CreateDiskEncryptionServiceRequest is the request struct for api CreateDiskEncryptionService

func CreateCreateDiskEncryptionServiceRequest ¶

func CreateCreateDiskEncryptionServiceRequest() (request *CreateDiskEncryptionServiceRequest)

CreateCreateDiskEncryptionServiceRequest creates a request to invoke CreateDiskEncryptionService API

type CreateDiskEncryptionServiceResponse ¶

type CreateDiskEncryptionServiceResponse struct {
	*responses.BaseResponse
	OrderId   string `json:"OrderId" xml:"OrderId"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Success   bool   `json:"Success" xml:"Success"`
}

CreateDiskEncryptionServiceResponse is the response struct for api CreateDiskEncryptionService

func CreateCreateDiskEncryptionServiceResponse ¶

func CreateCreateDiskEncryptionServiceResponse() (response *CreateDiskEncryptionServiceResponse)

CreateCreateDiskEncryptionServiceResponse creates a response to parse from CreateDiskEncryptionService response

type CreateImageRequest ¶

type CreateImageRequest struct {
	*requests.RpcRequest
	SnapshotId        string           `position:"Query" name:"SnapshotId"`
	SnapshotIds       *[]string        `position:"Query" name:"SnapshotIds"  type:"Repeated"`
	Description       string           `position:"Query" name:"Description"`
	DiskType          string           `position:"Query" name:"DiskType"`
	ImageName         string           `position:"Query" name:"ImageName"`
	AutoCleanUserdata requests.Boolean `position:"Query" name:"AutoCleanUserdata"`
	DesktopId         string           `position:"Query" name:"DesktopId"`
	ImageResourceType string           `position:"Query" name:"ImageResourceType"`
}

CreateImageRequest is the request struct for api CreateImage

func CreateCreateImageRequest ¶

func CreateCreateImageRequest() (request *CreateImageRequest)

CreateCreateImageRequest creates a request to invoke CreateImage API

type CreateImageResponse ¶

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

CreateImageResponse is the response struct for api CreateImage

func CreateCreateImageResponse ¶

func CreateCreateImageResponse() (response *CreateImageResponse)

CreateCreateImageResponse creates a response to parse from CreateImage response

type CreateNASFileSystemRequest ¶

type CreateNASFileSystemRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
	Description  string `position:"Query" name:"Description"`
	StorageType  string `position:"Query" name:"StorageType"`
	EncryptType  string `position:"Query" name:"EncryptType"`
	Name         string `position:"Query" name:"Name"`
}

CreateNASFileSystemRequest is the request struct for api CreateNASFileSystem

func CreateCreateNASFileSystemRequest ¶

func CreateCreateNASFileSystemRequest() (request *CreateNASFileSystemRequest)

CreateCreateNASFileSystemRequest creates a request to invoke CreateNASFileSystem API

type CreateNASFileSystemResponse ¶

type CreateNASFileSystemResponse struct {
	*responses.BaseResponse
	FileSystemId      string `json:"FileSystemId" xml:"FileSystemId"`
	FileSystemName    string `json:"FileSystemName" xml:"FileSystemName"`
	MountTargetDomain string `json:"MountTargetDomain" xml:"MountTargetDomain"`
	RequestId         string `json:"RequestId" xml:"RequestId"`
	OfficeSiteId      string `json:"OfficeSiteId" xml:"OfficeSiteId"`
}

CreateNASFileSystemResponse is the response struct for api CreateNASFileSystem

func CreateCreateNASFileSystemResponse ¶

func CreateCreateNASFileSystemResponse() (response *CreateNASFileSystemResponse)

CreateCreateNASFileSystemResponse creates a response to parse from CreateNASFileSystem response

type CreateNetworkPackageRequest ¶

type CreateNetworkPackageRequest struct {
	*requests.RpcRequest
	OfficeSiteId       string           `position:"Query" name:"OfficeSiteId"`
	Period             requests.Integer `position:"Query" name:"Period"`
	AutoPay            requests.Boolean `position:"Query" name:"AutoPay"`
	Bandwidth          requests.Integer `position:"Query" name:"Bandwidth"`
	PromotionId        string           `position:"Query" name:"PromotionId"`
	PeriodUnit         string           `position:"Query" name:"PeriodUnit"`
	AutoRenew          requests.Boolean `position:"Query" name:"AutoRenew"`
	InternetChargeType string           `position:"Query" name:"InternetChargeType"`
}

CreateNetworkPackageRequest is the request struct for api CreateNetworkPackage

func CreateCreateNetworkPackageRequest ¶

func CreateCreateNetworkPackageRequest() (request *CreateNetworkPackageRequest)

CreateCreateNetworkPackageRequest creates a request to invoke CreateNetworkPackage API

type CreateNetworkPackageResponse ¶

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

CreateNetworkPackageResponse is the response struct for api CreateNetworkPackage

func CreateCreateNetworkPackageResponse ¶

func CreateCreateNetworkPackageResponse() (response *CreateNetworkPackageResponse)

CreateCreateNetworkPackageResponse creates a response to parse from CreateNetworkPackage response

type CreatePolicyGroupAuthorizeAccessPolicyRule ¶

type CreatePolicyGroupAuthorizeAccessPolicyRule struct {
	Description string `name:"Description"`
	CidrIp      string `name:"CidrIp"`
}

CreatePolicyGroupAuthorizeAccessPolicyRule is a repeated param struct in CreatePolicyGroupRequest

type CreatePolicyGroupAuthorizeSecurityPolicyRule ¶

type CreatePolicyGroupAuthorizeSecurityPolicyRule struct {
	PortRange   string `name:"PortRange"`
	IpProtocol  string `name:"IpProtocol"`
	Description string `name:"Description"`
	Type        string `name:"Type"`
	Priority    string `name:"Priority"`
	CidrIp      string `name:"CidrIp"`
	Policy      string `name:"Policy"`
}

CreatePolicyGroupAuthorizeSecurityPolicyRule is a repeated param struct in CreatePolicyGroupRequest

type CreatePolicyGroupClientType ¶

type CreatePolicyGroupClientType struct {
	ClientType string `name:"ClientType"`
	Status     string `name:"Status"`
}

CreatePolicyGroupClientType is a repeated param struct in CreatePolicyGroupRequest

type CreatePolicyGroupRequest ¶

type CreatePolicyGroupRequest struct {
	*requests.RpcRequest
	WatermarkCustomText         string                                          `position:"Query" name:"WatermarkCustomText"`
	PreemptLogin                string                                          `position:"Query" name:"PreemptLogin"`
	ClientType                  *[]CreatePolicyGroupClientType                  `position:"Query" name:"ClientType"  type:"Repeated"`
	UsbSupplyRedirectRule       *[]CreatePolicyGroupUsbSupplyRedirectRule       `position:"Query" name:"UsbSupplyRedirectRule"  type:"Repeated"`
	PrinterRedirection          string                                          `position:"Query" name:"PrinterRedirection"`
	PreemptLoginUser            *[]string                                       `position:"Query" name:"PreemptLoginUser"  type:"Repeated"`
	DomainList                  string                                          `position:"Query" name:"DomainList"`
	NetRedirect                 string                                          `position:"Query" name:"NetRedirect"`
	LocalDrive                  string                                          `position:"Query" name:"LocalDrive"`
	AuthorizeSecurityPolicyRule *[]CreatePolicyGroupAuthorizeSecurityPolicyRule `position:"Query" name:"AuthorizeSecurityPolicyRule"  type:"Repeated"`
	Recording                   string                                          `position:"Query" name:"Recording"`
	Clipboard                   string                                          `position:"Query" name:"Clipboard"`
	RecordingFps                requests.Integer                                `position:"Query" name:"RecordingFps"`
	UsbRedirect                 string                                          `position:"Query" name:"UsbRedirect"`
	WatermarkType               string                                          `position:"Query" name:"WatermarkType"`
	RecordingStartTime          string                                          `position:"Query" name:"RecordingStartTime"`
	Watermark                   string                                          `position:"Query" name:"Watermark"`
	CameraRedirect              string                                          `position:"Query" name:"CameraRedirect"`
	Html5Access                 string                                          `position:"Query" name:"Html5Access"`
	GpuAcceleration             string                                          `position:"Query" name:"GpuAcceleration"`
	Html5FileTransfer           string                                          `position:"Query" name:"Html5FileTransfer"`
	AuthorizeAccessPolicyRule   *[]CreatePolicyGroupAuthorizeAccessPolicyRule   `position:"Query" name:"AuthorizeAccessPolicyRule"  type:"Repeated"`
	VisualQuality               string                                          `position:"Query" name:"VisualQuality"`
	WatermarkTransparency       string                                          `position:"Query" name:"WatermarkTransparency"`
	Name                        string                                          `position:"Query" name:"Name"`
	RecordingEndTime            string                                          `position:"Query" name:"RecordingEndTime"`
}

CreatePolicyGroupRequest is the request struct for api CreatePolicyGroup

func CreateCreatePolicyGroupRequest ¶

func CreateCreatePolicyGroupRequest() (request *CreatePolicyGroupRequest)

CreateCreatePolicyGroupRequest creates a request to invoke CreatePolicyGroup API

type CreatePolicyGroupResponse ¶

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

CreatePolicyGroupResponse is the response struct for api CreatePolicyGroup

func CreateCreatePolicyGroupResponse ¶

func CreateCreatePolicyGroupResponse() (response *CreatePolicyGroupResponse)

CreateCreatePolicyGroupResponse creates a response to parse from CreatePolicyGroup response

type CreatePolicyGroupUsbSupplyRedirectRule ¶

type CreatePolicyGroupUsbSupplyRedirectRule struct {
	ProductId       string `name:"ProductId"`
	DeviceSubclass  string `name:"DeviceSubclass"`
	UsbRedirectType string `name:"UsbRedirectType"`
	VendorId        string `name:"VendorId"`
	Description     string `name:"Description"`
	DeviceClass     string `name:"DeviceClass"`
	UsbRuleType     string `name:"UsbRuleType"`
}

CreatePolicyGroupUsbSupplyRedirectRule is a repeated param struct in CreatePolicyGroupRequest

type CreateRAMDirectoryRequest ¶

type CreateRAMDirectoryRequest struct {
	*requests.RpcRequest
	DesktopAccessType    string           `position:"Query" name:"DesktopAccessType"`
	EnableInternetAccess requests.Boolean `position:"Query" name:"EnableInternetAccess"`
	DirectoryName        string           `position:"Query" name:"DirectoryName"`
	VSwitchId            *[]string        `position:"Query" name:"VSwitchId"  type:"Repeated"`
	EnableAdminAccess    requests.Boolean `position:"Query" name:"EnableAdminAccess"`
}

CreateRAMDirectoryRequest is the request struct for api CreateRAMDirectory

func CreateCreateRAMDirectoryRequest ¶

func CreateCreateRAMDirectoryRequest() (request *CreateRAMDirectoryRequest)

CreateCreateRAMDirectoryRequest creates a request to invoke CreateRAMDirectory API

type CreateRAMDirectoryResponse ¶

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

CreateRAMDirectoryResponse is the response struct for api CreateRAMDirectory

func CreateCreateRAMDirectoryResponse ¶

func CreateCreateRAMDirectoryResponse() (response *CreateRAMDirectoryResponse)

CreateCreateRAMDirectoryResponse creates a response to parse from CreateRAMDirectory response

type CreateSimpleOfficeSiteRequest ¶

type CreateSimpleOfficeSiteRequest struct {
	*requests.RpcRequest
	CenId                string           `position:"Query" name:"CenId"`
	CenOwnerId           requests.Integer `position:"Query" name:"CenOwnerId"`
	EnableInternetAccess requests.Boolean `position:"Query" name:"EnableInternetAccess"`
	VerifyCode           string           `position:"Query" name:"VerifyCode"`
	NeedVerifyZeroDevice requests.Boolean `position:"Query" name:"NeedVerifyZeroDevice"`
	EnableAdminAccess    requests.Boolean `position:"Query" name:"EnableAdminAccess"`
	Bandwidth            requests.Integer `position:"Query" name:"Bandwidth"`
	DesktopAccessType    string           `position:"Query" name:"DesktopAccessType"`
	OfficeSiteName       string           `position:"Query" name:"OfficeSiteName"`
	CloudBoxOfficeSite   requests.Boolean `position:"Query" name:"CloudBoxOfficeSite"`
	VSwitchId            *[]string        `position:"Query" name:"VSwitchId"  type:"Repeated"`
	CidrBlock            string           `position:"Query" name:"CidrBlock"`
}

CreateSimpleOfficeSiteRequest is the request struct for api CreateSimpleOfficeSite

func CreateCreateSimpleOfficeSiteRequest ¶

func CreateCreateSimpleOfficeSiteRequest() (request *CreateSimpleOfficeSiteRequest)

CreateCreateSimpleOfficeSiteRequest creates a request to invoke CreateSimpleOfficeSite API

type CreateSimpleOfficeSiteResponse ¶

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

CreateSimpleOfficeSiteResponse is the response struct for api CreateSimpleOfficeSite

func CreateCreateSimpleOfficeSiteResponse ¶

func CreateCreateSimpleOfficeSiteResponse() (response *CreateSimpleOfficeSiteResponse)

CreateCreateSimpleOfficeSiteResponse creates a response to parse from CreateSimpleOfficeSite response

type CreateSnapshotRequest ¶

type CreateSnapshotRequest struct {
	*requests.RpcRequest
	Description    string `position:"Query" name:"Description"`
	SourceDiskType string `position:"Query" name:"SourceDiskType"`
	SnapshotName   string `position:"Query" name:"SnapshotName"`
	DesktopId      string `position:"Query" name:"DesktopId"`
}

CreateSnapshotRequest is the request struct for api CreateSnapshot

func CreateCreateSnapshotRequest ¶

func CreateCreateSnapshotRequest() (request *CreateSnapshotRequest)

CreateCreateSnapshotRequest creates a request to invoke CreateSnapshot API

type CreateSnapshotResponse ¶

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

CreateSnapshotResponse is the response struct for api CreateSnapshot

func CreateCreateSnapshotResponse ¶

func CreateCreateSnapshotResponse() (response *CreateSnapshotResponse)

CreateCreateSnapshotResponse creates a response to parse from CreateSnapshot response

type Cve ¶

type Cve struct {
	CveId     string `json:"CveId" xml:"CveId"`
	Summary   string `json:"Summary" xml:"Summary"`
	Title     string `json:"Title" xml:"Title"`
	CvssScore string `json:"CvssScore" xml:"CvssScore"`
}

Cve is a nested struct in ecd response

type Cves ¶

type Cves struct {
	Cve []Cve `json:"Cve" xml:"Cve"`
}

Cves is a nested struct in ecd response

type DeleteBundlesRequest ¶

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

DeleteBundlesRequest is the request struct for api DeleteBundles

func CreateDeleteBundlesRequest ¶

func CreateDeleteBundlesRequest() (request *DeleteBundlesRequest)

CreateDeleteBundlesRequest creates a request to invoke DeleteBundles API

type DeleteBundlesResponse ¶

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

DeleteBundlesResponse is the response struct for api DeleteBundles

func CreateDeleteBundlesResponse ¶

func CreateDeleteBundlesResponse() (response *DeleteBundlesResponse)

CreateDeleteBundlesResponse creates a response to parse from DeleteBundles response

type DeleteDesktopGroupRequest ¶

type DeleteDesktopGroupRequest struct {
	*requests.RpcRequest
	DesktopGroupId string `position:"Query" name:"DesktopGroupId"`
}

DeleteDesktopGroupRequest is the request struct for api DeleteDesktopGroup

func CreateDeleteDesktopGroupRequest ¶

func CreateDeleteDesktopGroupRequest() (request *DeleteDesktopGroupRequest)

CreateDeleteDesktopGroupRequest creates a request to invoke DeleteDesktopGroup API

type DeleteDesktopGroupResponse ¶

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

DeleteDesktopGroupResponse is the response struct for api DeleteDesktopGroup

func CreateDeleteDesktopGroupResponse ¶

func CreateDeleteDesktopGroupResponse() (response *DeleteDesktopGroupResponse)

CreateDeleteDesktopGroupResponse creates a response to parse from DeleteDesktopGroup response

type DeleteDesktopsRequest ¶

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

DeleteDesktopsRequest is the request struct for api DeleteDesktops

func CreateDeleteDesktopsRequest ¶

func CreateDeleteDesktopsRequest() (request *DeleteDesktopsRequest)

CreateDeleteDesktopsRequest creates a request to invoke DeleteDesktops API

type DeleteDesktopsResponse ¶

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

DeleteDesktopsResponse is the response struct for api DeleteDesktops

func CreateDeleteDesktopsResponse ¶

func CreateDeleteDesktopsResponse() (response *DeleteDesktopsResponse)

CreateDeleteDesktopsResponse creates a response to parse from DeleteDesktops response

type DeleteDirectoriesRequest ¶

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

DeleteDirectoriesRequest is the request struct for api DeleteDirectories

func CreateDeleteDirectoriesRequest ¶

func CreateDeleteDirectoriesRequest() (request *DeleteDirectoriesRequest)

CreateDeleteDirectoriesRequest creates a request to invoke DeleteDirectories API

type DeleteDirectoriesResponse ¶

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

DeleteDirectoriesResponse is the response struct for api DeleteDirectories

func CreateDeleteDirectoriesResponse ¶

func CreateDeleteDirectoriesResponse() (response *DeleteDirectoriesResponse)

CreateDeleteDirectoriesResponse creates a response to parse from DeleteDirectories response

type DeleteImagesRequest ¶

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

DeleteImagesRequest is the request struct for api DeleteImages

func CreateDeleteImagesRequest ¶

func CreateDeleteImagesRequest() (request *DeleteImagesRequest)

CreateDeleteImagesRequest creates a request to invoke DeleteImages API

type DeleteImagesResponse ¶

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

DeleteImagesResponse is the response struct for api DeleteImages

func CreateDeleteImagesResponse ¶

func CreateDeleteImagesResponse() (response *DeleteImagesResponse)

CreateDeleteImagesResponse creates a response to parse from DeleteImages response

type DeleteNASFileSystemsRequest ¶

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

DeleteNASFileSystemsRequest is the request struct for api DeleteNASFileSystems

func CreateDeleteNASFileSystemsRequest ¶

func CreateDeleteNASFileSystemsRequest() (request *DeleteNASFileSystemsRequest)

CreateDeleteNASFileSystemsRequest creates a request to invoke DeleteNASFileSystems API

type DeleteNASFileSystemsResponse ¶

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

DeleteNASFileSystemsResponse is the response struct for api DeleteNASFileSystems

func CreateDeleteNASFileSystemsResponse ¶

func CreateDeleteNASFileSystemsResponse() (response *DeleteNASFileSystemsResponse)

CreateDeleteNASFileSystemsResponse creates a response to parse from DeleteNASFileSystems response

type DeleteNetworkPackagesRequest ¶

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

DeleteNetworkPackagesRequest is the request struct for api DeleteNetworkPackages

func CreateDeleteNetworkPackagesRequest ¶

func CreateDeleteNetworkPackagesRequest() (request *DeleteNetworkPackagesRequest)

CreateDeleteNetworkPackagesRequest creates a request to invoke DeleteNetworkPackages API

type DeleteNetworkPackagesResponse ¶

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

DeleteNetworkPackagesResponse is the response struct for api DeleteNetworkPackages

func CreateDeleteNetworkPackagesResponse ¶

func CreateDeleteNetworkPackagesResponse() (response *DeleteNetworkPackagesResponse)

CreateDeleteNetworkPackagesResponse creates a response to parse from DeleteNetworkPackages response

type DeleteOfficeSitesRequest ¶

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

DeleteOfficeSitesRequest is the request struct for api DeleteOfficeSites

func CreateDeleteOfficeSitesRequest ¶

func CreateDeleteOfficeSitesRequest() (request *DeleteOfficeSitesRequest)

CreateDeleteOfficeSitesRequest creates a request to invoke DeleteOfficeSites API

type DeleteOfficeSitesResponse ¶

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

DeleteOfficeSitesResponse is the response struct for api DeleteOfficeSites

func CreateDeleteOfficeSitesResponse ¶

func CreateDeleteOfficeSitesResponse() (response *DeleteOfficeSitesResponse)

CreateDeleteOfficeSitesResponse creates a response to parse from DeleteOfficeSites response

type DeletePolicyGroupsRequest ¶

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

DeletePolicyGroupsRequest is the request struct for api DeletePolicyGroups

func CreateDeletePolicyGroupsRequest ¶

func CreateDeletePolicyGroupsRequest() (request *DeletePolicyGroupsRequest)

CreateDeletePolicyGroupsRequest creates a request to invoke DeletePolicyGroups API

type DeletePolicyGroupsResponse ¶

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

DeletePolicyGroupsResponse is the response struct for api DeletePolicyGroups

func CreateDeletePolicyGroupsResponse ¶

func CreateDeletePolicyGroupsResponse() (response *DeletePolicyGroupsResponse)

CreateDeletePolicyGroupsResponse creates a response to parse from DeletePolicyGroups response

type DeleteSnapshotRequest ¶

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

DeleteSnapshotRequest is the request struct for api DeleteSnapshot

func CreateDeleteSnapshotRequest ¶

func CreateDeleteSnapshotRequest() (request *DeleteSnapshotRequest)

CreateDeleteSnapshotRequest creates a request to invoke DeleteSnapshot API

type DeleteSnapshotResponse ¶

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

DeleteSnapshotResponse is the response struct for api DeleteSnapshot

func CreateDeleteSnapshotResponse ¶

func CreateDeleteSnapshotResponse() (response *DeleteSnapshotResponse)

CreateDeleteSnapshotResponse creates a response to parse from DeleteSnapshot response

type DeleteVirtualMFADeviceRequest ¶

type DeleteVirtualMFADeviceRequest struct {
	*requests.RpcRequest
	SerialNumber string `position:"Query" name:"SerialNumber"`
}

DeleteVirtualMFADeviceRequest is the request struct for api DeleteVirtualMFADevice

func CreateDeleteVirtualMFADeviceRequest ¶

func CreateDeleteVirtualMFADeviceRequest() (request *DeleteVirtualMFADeviceRequest)

CreateDeleteVirtualMFADeviceRequest creates a request to invoke DeleteVirtualMFADevice API

type DeleteVirtualMFADeviceResponse ¶

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

DeleteVirtualMFADeviceResponse is the response struct for api DeleteVirtualMFADevice

func CreateDeleteVirtualMFADeviceResponse ¶

func CreateDeleteVirtualMFADeviceResponse() (response *DeleteVirtualMFADeviceResponse)

CreateDeleteVirtualMFADeviceResponse creates a response to parse from DeleteVirtualMFADevice response

type DescribeAlarmEventStackInfoRequest ¶

type DescribeAlarmEventStackInfoRequest struct {
	*requests.RpcRequest
	UniqueInfo string `position:"Query" name:"UniqueInfo"`
	EventName  string `position:"Query" name:"EventName"`
	DesktopId  string `position:"Query" name:"DesktopId"`
	Lang       string `position:"Query" name:"Lang"`
}

DescribeAlarmEventStackInfoRequest is the request struct for api DescribeAlarmEventStackInfo

func CreateDescribeAlarmEventStackInfoRequest ¶

func CreateDescribeAlarmEventStackInfoRequest() (request *DescribeAlarmEventStackInfoRequest)

CreateDescribeAlarmEventStackInfoRequest creates a request to invoke DescribeAlarmEventStackInfo API

type DescribeAlarmEventStackInfoResponse ¶

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

DescribeAlarmEventStackInfoResponse is the response struct for api DescribeAlarmEventStackInfo

func CreateDescribeAlarmEventStackInfoResponse ¶

func CreateDescribeAlarmEventStackInfoResponse() (response *DescribeAlarmEventStackInfoResponse)

CreateDescribeAlarmEventStackInfoResponse creates a response to parse from DescribeAlarmEventStackInfo response

type DescribeBundlesRequest ¶

type DescribeBundlesRequest struct {
	*requests.RpcRequest
	GpuCount                requests.Float   `position:"Query" name:"GpuCount"`
	BundleId                *[]string        `position:"Query" name:"BundleId"  type:"Repeated"`
	DesktopTypeFamily       string           `position:"Query" name:"DesktopTypeFamily"`
	NextToken               string           `position:"Query" name:"NextToken"`
	FromDesktopGroup        requests.Boolean `position:"Query" name:"FromDesktopGroup"`
	BundleType              string           `position:"Query" name:"BundleType"`
	FotaChannel             string           `position:"Query" name:"FotaChannel"`
	VolumeEncryptionEnabled requests.Boolean `position:"Query" name:"VolumeEncryptionEnabled"`
	MemorySize              requests.Integer `position:"Query" name:"MemorySize"`
	MaxResults              requests.Integer `position:"Query" name:"MaxResults"`
	CheckStock              requests.Boolean `position:"Query" name:"CheckStock"`
	ProtocolType            string           `position:"Query" name:"ProtocolType"`
	CpuCount                requests.Integer `position:"Query" name:"CpuCount"`
	SupportMultiSession     requests.Boolean `position:"Query" name:"SupportMultiSession"`
}

DescribeBundlesRequest is the request struct for api DescribeBundles

func CreateDescribeBundlesRequest ¶

func CreateDescribeBundlesRequest() (request *DescribeBundlesRequest)

CreateDescribeBundlesRequest creates a request to invoke DescribeBundles API

type DescribeBundlesResponse ¶

type DescribeBundlesResponse struct {
	*responses.BaseResponse
	NextToken string   `json:"NextToken" xml:"NextToken"`
	RequestId string   `json:"RequestId" xml:"RequestId"`
	Bundles   []Bundle `json:"Bundles" xml:"Bundles"`
}

DescribeBundlesResponse is the response struct for api DescribeBundles

func CreateDescribeBundlesResponse ¶

func CreateDescribeBundlesResponse() (response *DescribeBundlesResponse)

CreateDescribeBundlesResponse creates a response to parse from DescribeBundles response

type DescribeCensRequest ¶

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

DescribeCensRequest is the request struct for api DescribeCens

func CreateDescribeCensRequest ¶

func CreateDescribeCensRequest() (request *DescribeCensRequest)

CreateDescribeCensRequest creates a request to invoke DescribeCens API

type DescribeCensResponse ¶

type DescribeCensResponse struct {
	*responses.BaseResponse
	PageSize   int    `json:"PageSize" xml:"PageSize"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
	PageNumber int    `json:"PageNumber" xml:"PageNumber"`
	TotalCount int    `json:"TotalCount" xml:"TotalCount"`
	Cens       []Cen  `json:"Cens" xml:"Cens"`
}

DescribeCensResponse is the response struct for api DescribeCens

func CreateDescribeCensResponse ¶

func CreateDescribeCensResponse() (response *DescribeCensResponse)

CreateDescribeCensResponse creates a response to parse from DescribeCens response

type DescribeClientEventsRequest ¶

type DescribeClientEventsRequest struct {
	*requests.RpcRequest
	OfficeSiteId   string           `position:"Query" name:"OfficeSiteId"`
	StartTime      string           `position:"Query" name:"StartTime"`
	NextToken      string           `position:"Query" name:"NextToken"`
	EndUserId      string           `position:"Query" name:"EndUserId"`
	DirectoryId    string           `position:"Query" name:"DirectoryId"`
	DesktopId      string           `position:"Query" name:"DesktopId"`
	DesktopName    string           `position:"Query" name:"DesktopName"`
	EndTime        string           `position:"Query" name:"EndTime"`
	OfficeSiteName string           `position:"Query" name:"OfficeSiteName"`
	DesktopIp      string           `position:"Query" name:"DesktopIp"`
	MaxResults     requests.Integer `position:"Query" name:"MaxResults"`
	EventType      string           `position:"Query" name:"EventType"`
}

DescribeClientEventsRequest is the request struct for api DescribeClientEvents

func CreateDescribeClientEventsRequest ¶

func CreateDescribeClientEventsRequest() (request *DescribeClientEventsRequest)

CreateDescribeClientEventsRequest creates a request to invoke DescribeClientEvents API

type DescribeClientEventsResponse ¶

type DescribeClientEventsResponse struct {
	*responses.BaseResponse
	NextToken string  `json:"NextToken" xml:"NextToken"`
	RequestId string  `json:"RequestId" xml:"RequestId"`
	Events    []Event `json:"Events" xml:"Events"`
}

DescribeClientEventsResponse is the response struct for api DescribeClientEvents

func CreateDescribeClientEventsResponse ¶

func CreateDescribeClientEventsResponse() (response *DescribeClientEventsResponse)

CreateDescribeClientEventsResponse creates a response to parse from DescribeClientEvents response

type DescribeDesktopGroupsRequest ¶

type DescribeDesktopGroupsRequest struct {
	*requests.RpcRequest
	OfficeSiteId       string           `position:"Query" name:"OfficeSiteId"`
	EndUserIds         *[]string        `position:"Query" name:"EndUserIds"  type:"Repeated"`
	DesktopGroupName   string           `position:"Query" name:"DesktopGroupName"`
	DesktopGroupId     string           `position:"Query" name:"DesktopGroupId"`
	NextToken          string           `position:"Query" name:"NextToken"`
	Period             requests.Integer `position:"Query" name:"Period"`
	OwnType            requests.Integer `position:"Query" name:"OwnType"`
	ExcludedEndUserIds *[]string        `position:"Query" name:"ExcludedEndUserIds"  type:"Repeated"`
	PeriodUnit         string           `position:"Query" name:"PeriodUnit"`
	MaxResults         requests.Integer `position:"Query" name:"MaxResults"`
	PolicyGroupId      string           `position:"Query" name:"PolicyGroupId"`
	Status             requests.Integer `position:"Query" name:"Status"`
}

DescribeDesktopGroupsRequest is the request struct for api DescribeDesktopGroups

func CreateDescribeDesktopGroupsRequest ¶

func CreateDescribeDesktopGroupsRequest() (request *DescribeDesktopGroupsRequest)

CreateDescribeDesktopGroupsRequest creates a request to invoke DescribeDesktopGroups API

type DescribeDesktopGroupsResponse ¶

type DescribeDesktopGroupsResponse struct {
	*responses.BaseResponse
	NextToken     string         `json:"NextToken" xml:"NextToken"`
	RequestId     string         `json:"RequestId" xml:"RequestId"`
	DesktopGroups []DesktopGroup `json:"DesktopGroups" xml:"DesktopGroups"`
}

DescribeDesktopGroupsResponse is the response struct for api DescribeDesktopGroups

func CreateDescribeDesktopGroupsResponse ¶

func CreateDescribeDesktopGroupsResponse() (response *DescribeDesktopGroupsResponse)

CreateDescribeDesktopGroupsResponse creates a response to parse from DescribeDesktopGroups response

type DescribeDesktopIdsByVulNamesRequest ¶

type DescribeDesktopIdsByVulNamesRequest struct {
	*requests.RpcRequest
	OfficeSiteId string    `position:"Query" name:"OfficeSiteId"`
	Type         string    `position:"Query" name:"Type"`
	VulName      *[]string `position:"Query" name:"VulName"  type:"Repeated"`
	Necessity    string    `position:"Query" name:"Necessity"`
}

DescribeDesktopIdsByVulNamesRequest is the request struct for api DescribeDesktopIdsByVulNames

func CreateDescribeDesktopIdsByVulNamesRequest ¶

func CreateDescribeDesktopIdsByVulNamesRequest() (request *DescribeDesktopIdsByVulNamesRequest)

CreateDescribeDesktopIdsByVulNamesRequest creates a request to invoke DescribeDesktopIdsByVulNames API

type DescribeDesktopIdsByVulNamesResponse ¶

type DescribeDesktopIdsByVulNamesResponse struct {
	*responses.BaseResponse
	RequestId    string        `json:"RequestId" xml:"RequestId"`
	DesktopItems []DesktopItem `json:"DesktopItems" xml:"DesktopItems"`
}

DescribeDesktopIdsByVulNamesResponse is the response struct for api DescribeDesktopIdsByVulNames

func CreateDescribeDesktopIdsByVulNamesResponse ¶

func CreateDescribeDesktopIdsByVulNamesResponse() (response *DescribeDesktopIdsByVulNamesResponse)

CreateDescribeDesktopIdsByVulNamesResponse creates a response to parse from DescribeDesktopIdsByVulNames response

type DescribeDesktopTypesRequest ¶

type DescribeDesktopTypesRequest struct {
	*requests.RpcRequest
	AppliedScope       string           `position:"Query" name:"AppliedScope"`
	MemorySize         requests.Integer `position:"Query" name:"MemorySize"`
	GpuCount           requests.Float   `position:"Query" name:"GpuCount"`
	InstanceTypeFamily string           `position:"Query" name:"InstanceTypeFamily"`
	DesktopTypeId      string           `position:"Query" name:"DesktopTypeId"`
	DesktopIdForModify string           `position:"Query" name:"DesktopIdForModify"`
	CpuCount           requests.Integer `position:"Query" name:"CpuCount"`
	OrderType          string           `position:"Query" name:"OrderType"`
}

DescribeDesktopTypesRequest is the request struct for api DescribeDesktopTypes

func CreateDescribeDesktopTypesRequest ¶

func CreateDescribeDesktopTypesRequest() (request *DescribeDesktopTypesRequest)

CreateDescribeDesktopTypesRequest creates a request to invoke DescribeDesktopTypes API

type DescribeDesktopTypesResponse ¶

type DescribeDesktopTypesResponse struct {
	*responses.BaseResponse
	RequestId    string        `json:"RequestId" xml:"RequestId"`
	DesktopTypes []DesktopType `json:"DesktopTypes" xml:"DesktopTypes"`
}

DescribeDesktopTypesResponse is the response struct for api DescribeDesktopTypes

func CreateDescribeDesktopTypesResponse ¶

func CreateDescribeDesktopTypesResponse() (response *DescribeDesktopTypesResponse)

CreateDescribeDesktopTypesResponse creates a response to parse from DescribeDesktopTypes response

type DescribeDesktopsInGroupRequest ¶

type DescribeDesktopsInGroupRequest struct {
	*requests.RpcRequest
	DesktopGroupId string           `position:"Query" name:"DesktopGroupId"`
	NextToken      string           `position:"Query" name:"NextToken"`
	MaxResults     requests.Integer `position:"Query" name:"MaxResults"`
	PayType        string           `position:"Query" name:"PayType"`
}

DescribeDesktopsInGroupRequest is the request struct for api DescribeDesktopsInGroup

func CreateDescribeDesktopsInGroupRequest ¶

func CreateDescribeDesktopsInGroupRequest() (request *DescribeDesktopsInGroupRequest)

CreateDescribeDesktopsInGroupRequest creates a request to invoke DescribeDesktopsInGroup API

type DescribeDesktopsInGroupResponse ¶

type DescribeDesktopsInGroupResponse struct {
	*responses.BaseResponse
	PostPaidDesktopsCount       int               `json:"PostPaidDesktopsCount" xml:"PostPaidDesktopsCount"`
	NextToken                   string            `json:"NextToken" xml:"NextToken"`
	PaidDesktopsCount           int               `json:"PaidDesktopsCount" xml:"PaidDesktopsCount"`
	RequestId                   string            `json:"RequestId" xml:"RequestId"`
	PostPaidDesktopsTotalAmount int               `json:"PostPaidDesktopsTotalAmount" xml:"PostPaidDesktopsTotalAmount"`
	OnlinePrePaidDesktopsCount  int               `json:"OnlinePrePaidDesktopsCount" xml:"OnlinePrePaidDesktopsCount"`
	RunningPrePaidDesktopsCount int               `json:"RunningPrePaidDesktopsCount" xml:"RunningPrePaidDesktopsCount"`
	StopedPrePaidDesktopsCount  int               `json:"StopedPrePaidDesktopsCount" xml:"StopedPrePaidDesktopsCount"`
	PaidDesktops                []PaidDesktop     `json:"PaidDesktops" xml:"PaidDesktops"`
	PostPaidDesktops            []PostPaidDesktop `json:"PostPaidDesktops" xml:"PostPaidDesktops"`
}

DescribeDesktopsInGroupResponse is the response struct for api DescribeDesktopsInGroup

func CreateDescribeDesktopsInGroupResponse ¶

func CreateDescribeDesktopsInGroupResponse() (response *DescribeDesktopsInGroupResponse)

CreateDescribeDesktopsInGroupResponse creates a response to parse from DescribeDesktopsInGroup response

type DescribeDesktopsRequest ¶

type DescribeDesktopsRequest struct {
	*requests.RpcRequest
	OfficeSiteId       string           `position:"Query" name:"OfficeSiteId"`
	DesktopStatus      string           `position:"Query" name:"DesktopStatus"`
	NextToken          string           `position:"Query" name:"NextToken"`
	QueryFotaUpdate    requests.Boolean `position:"Query" name:"QueryFotaUpdate"`
	DirectoryId        string           `position:"Query" name:"DirectoryId"`
	EndUserId          *[]string        `position:"Query" name:"EndUserId"  type:"Repeated"`
	DesktopId          *[]string        `position:"Query" name:"DesktopId"  type:"Repeated"`
	DesktopName        string           `position:"Query" name:"DesktopName"`
	GroupId            string           `position:"Query" name:"GroupId"`
	OfficeSiteName     string           `position:"Query" name:"OfficeSiteName"`
	ExcludedEndUserId  *[]string        `position:"Query" name:"ExcludedEndUserId"  type:"Repeated"`
	FilterDesktopGroup requests.Boolean `position:"Query" name:"FilterDesktopGroup"`
	ManagementFlag     string           `position:"Query" name:"ManagementFlag"`
	ExpiredTime        string           `position:"Query" name:"ExpiredTime"`
	MaxResults         requests.Integer `position:"Query" name:"MaxResults"`
	ProtocolType       string           `position:"Query" name:"ProtocolType"`
	ChargeType         string           `position:"Query" name:"ChargeType"`
	PolicyGroupId      string           `position:"Query" name:"PolicyGroupId"`
	UserName           string           `position:"Query" name:"UserName"`
}

DescribeDesktopsRequest is the request struct for api DescribeDesktops

func CreateDescribeDesktopsRequest ¶

func CreateDescribeDesktopsRequest() (request *DescribeDesktopsRequest)

CreateDescribeDesktopsRequest creates a request to invoke DescribeDesktops API

type DescribeDesktopsResponse ¶

type DescribeDesktopsResponse struct {
	*responses.BaseResponse
	NextToken  string    `json:"NextToken" xml:"NextToken"`
	RequestId  string    `json:"RequestId" xml:"RequestId"`
	TotalCount int       `json:"TotalCount" xml:"TotalCount"`
	Desktops   []Desktop `json:"Desktops" xml:"Desktops"`
}

DescribeDesktopsResponse is the response struct for api DescribeDesktops

func CreateDescribeDesktopsResponse ¶

func CreateDescribeDesktopsResponse() (response *DescribeDesktopsResponse)

CreateDescribeDesktopsResponse creates a response to parse from DescribeDesktops response

type DescribeDirectoriesRequest ¶

type DescribeDirectoriesRequest struct {
	*requests.RpcRequest
	DirectoryType   string           `position:"Query" name:"DirectoryType"`
	NextToken       string           `position:"Query" name:"NextToken"`
	DirectoryStatus string           `position:"Query" name:"DirectoryStatus"`
	MaxResults      requests.Integer `position:"Query" name:"MaxResults"`
	DirectoryId     *[]string        `position:"Query" name:"DirectoryId"  type:"Repeated"`
	Status          string           `position:"Query" name:"Status"`
}

DescribeDirectoriesRequest is the request struct for api DescribeDirectories

func CreateDescribeDirectoriesRequest ¶

func CreateDescribeDirectoriesRequest() (request *DescribeDirectoriesRequest)

CreateDescribeDirectoriesRequest creates a request to invoke DescribeDirectories API

type DescribeDirectoriesResponse ¶

type DescribeDirectoriesResponse struct {
	*responses.BaseResponse
	NextToken   string      `json:"NextToken" xml:"NextToken"`
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	AdHostname  string      `json:"AdHostname" xml:"AdHostname"`
	Directories []Directory `json:"Directories" xml:"Directories"`
}

DescribeDirectoriesResponse is the response struct for api DescribeDirectories

func CreateDescribeDirectoriesResponse ¶

func CreateDescribeDirectoriesResponse() (response *DescribeDirectoriesResponse)

CreateDescribeDirectoriesResponse creates a response to parse from DescribeDirectories response

type DescribeFlowMetricRequest ¶

type DescribeFlowMetricRequest struct {
	*requests.RpcRequest
	MetricType   string           `position:"Query" name:"MetricType"`
	Period       requests.Integer `position:"Query" name:"Period"`
	EndTime      string           `position:"Query" name:"EndTime"`
	StartTime    string           `position:"Query" name:"StartTime"`
	InstanceId   string           `position:"Query" name:"InstanceId"`
	InstanceType string           `position:"Query" name:"InstanceType"`
}

DescribeFlowMetricRequest is the request struct for api DescribeFlowMetric

func CreateDescribeFlowMetricRequest ¶

func CreateDescribeFlowMetricRequest() (request *DescribeFlowMetricRequest)

CreateDescribeFlowMetricRequest creates a request to invoke DescribeFlowMetric API

type DescribeFlowMetricResponse ¶

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

DescribeFlowMetricResponse is the response struct for api DescribeFlowMetric

func CreateDescribeFlowMetricResponse ¶

func CreateDescribeFlowMetricResponse() (response *DescribeFlowMetricResponse)

CreateDescribeFlowMetricResponse creates a response to parse from DescribeFlowMetric response

type DescribeFlowStatisticRequest ¶

type DescribeFlowStatisticRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	Period       requests.Integer `position:"Query" name:"Period"`
	PageNumber   requests.Integer `position:"Query" name:"PageNumber"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	DesktopId    string           `position:"Query" name:"DesktopId"`
}

DescribeFlowStatisticRequest is the request struct for api DescribeFlowStatistic

func CreateDescribeFlowStatisticRequest ¶

func CreateDescribeFlowStatisticRequest() (request *DescribeFlowStatisticRequest)

CreateDescribeFlowStatisticRequest creates a request to invoke DescribeFlowStatistic API

type DescribeFlowStatisticResponse ¶

type DescribeFlowStatisticResponse struct {
	*responses.BaseResponse
	DesktopCount         int             `json:"DesktopCount" xml:"DesktopCount"`
	RequestId            string          `json:"RequestId" xml:"RequestId"`
	DesktopFlowStatistic []FlowStatistic `json:"DesktopFlowStatistic" xml:"DesktopFlowStatistic"`
}

DescribeFlowStatisticResponse is the response struct for api DescribeFlowStatistic

func CreateDescribeFlowStatisticResponse ¶

func CreateDescribeFlowStatisticResponse() (response *DescribeFlowStatisticResponse)

CreateDescribeFlowStatisticResponse creates a response to parse from DescribeFlowStatistic response

type DescribeFotaPendingDesktopsRequest ¶

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

DescribeFotaPendingDesktopsRequest is the request struct for api DescribeFotaPendingDesktops

func CreateDescribeFotaPendingDesktopsRequest ¶

func CreateDescribeFotaPendingDesktopsRequest() (request *DescribeFotaPendingDesktopsRequest)

CreateDescribeFotaPendingDesktopsRequest creates a request to invoke DescribeFotaPendingDesktops API

type DescribeFotaPendingDesktopsResponse ¶

type DescribeFotaPendingDesktopsResponse struct {
	*responses.BaseResponse
	NextToken           string               `json:"NextToken" xml:"NextToken"`
	RequestId           string               `json:"RequestId" xml:"RequestId"`
	FotaPendingDesktops []FotaPendingDesktop `json:"FotaPendingDesktops" xml:"FotaPendingDesktops"`
}

DescribeFotaPendingDesktopsResponse is the response struct for api DescribeFotaPendingDesktops

func CreateDescribeFotaPendingDesktopsResponse ¶

func CreateDescribeFotaPendingDesktopsResponse() (response *DescribeFotaPendingDesktopsResponse)

CreateDescribeFotaPendingDesktopsResponse creates a response to parse from DescribeFotaPendingDesktops response

type DescribeFotaTasksRequest ¶

type DescribeFotaTasksRequest struct {
	*requests.RpcRequest
	UserStatus string           `position:"Query" name:"UserStatus"`
	FotaStatus string           `position:"Query" name:"FotaStatus"`
	TaskUid    *[]string        `position:"Query" name:"TaskUid"  type:"Repeated"`
	NextToken  string           `position:"Query" name:"NextToken"`
	MaxResults requests.Integer `position:"Query" name:"MaxResults"`
}

DescribeFotaTasksRequest is the request struct for api DescribeFotaTasks

func CreateDescribeFotaTasksRequest ¶

func CreateDescribeFotaTasksRequest() (request *DescribeFotaTasksRequest)

CreateDescribeFotaTasksRequest creates a request to invoke DescribeFotaTasks API

type DescribeFotaTasksResponse ¶

type DescribeFotaTasksResponse struct {
	*responses.BaseResponse
	RequestId string     `json:"RequestId" xml:"RequestId"`
	FotaTasks []FotaTask `json:"FotaTasks" xml:"FotaTasks"`
}

DescribeFotaTasksResponse is the response struct for api DescribeFotaTasks

func CreateDescribeFotaTasksResponse ¶

func CreateDescribeFotaTasksResponse() (response *DescribeFotaTasksResponse)

CreateDescribeFotaTasksResponse creates a response to parse from DescribeFotaTasks response

type DescribeFrontVulPatchListRequest ¶

type DescribeFrontVulPatchListRequest struct {
	*requests.RpcRequest
	Type        string                              `position:"Query" name:"Type"`
	VulInfo     *[]DescribeFrontVulPatchListVulInfo `position:"Query" name:"VulInfo"  type:"Repeated"`
	OperateType string                              `position:"Query" name:"OperateType"`
}

DescribeFrontVulPatchListRequest is the request struct for api DescribeFrontVulPatchList

func CreateDescribeFrontVulPatchListRequest ¶

func CreateDescribeFrontVulPatchListRequest() (request *DescribeFrontVulPatchListRequest)

CreateDescribeFrontVulPatchListRequest creates a request to invoke DescribeFrontVulPatchList API

type DescribeFrontVulPatchListResponse ¶

type DescribeFrontVulPatchListResponse struct {
	*responses.BaseResponse
	RequestId      string           `json:"RequestId" xml:"RequestId"`
	FrontPatchList []FrontPatchItem `json:"FrontPatchList" xml:"FrontPatchList"`
}

DescribeFrontVulPatchListResponse is the response struct for api DescribeFrontVulPatchList

func CreateDescribeFrontVulPatchListResponse ¶

func CreateDescribeFrontVulPatchListResponse() (response *DescribeFrontVulPatchListResponse)

CreateDescribeFrontVulPatchListResponse creates a response to parse from DescribeFrontVulPatchList response

type DescribeFrontVulPatchListVulInfo ¶

type DescribeFrontVulPatchListVulInfo struct {
	Name      string `name:"Name"`
	DesktopId string `name:"DesktopId"`
	Tag       string `name:"Tag"`
}

DescribeFrontVulPatchListVulInfo is a repeated param struct in DescribeFrontVulPatchListRequest

type DescribeGroupedVulRequest ¶

type DescribeGroupedVulRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	Dealed       string           `position:"Query" name:"Dealed"`
	CurrentPage  requests.Integer `position:"Query" name:"CurrentPage"`
	Type         string           `position:"Query" name:"Type"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	Lang         string           `position:"Query" name:"Lang"`
	Necessity    string           `position:"Query" name:"Necessity"`
}

DescribeGroupedVulRequest is the request struct for api DescribeGroupedVul

func CreateDescribeGroupedVulRequest ¶

func CreateDescribeGroupedVulRequest() (request *DescribeGroupedVulRequest)

CreateDescribeGroupedVulRequest creates a request to invoke DescribeGroupedVul API

type DescribeGroupedVulResponse ¶

type DescribeGroupedVulResponse struct {
	*responses.BaseResponse
	CurrentPage     int              `json:"CurrentPage" xml:"CurrentPage"`
	RequestId       string           `json:"RequestId" xml:"RequestId"`
	PageSize        int              `json:"PageSize" xml:"PageSize"`
	TotalCount      int              `json:"TotalCount" xml:"TotalCount"`
	GroupedVulItems []GroupedVulItem `json:"GroupedVulItems" xml:"GroupedVulItems"`
}

DescribeGroupedVulResponse is the response struct for api DescribeGroupedVul

func CreateDescribeGroupedVulResponse ¶

func CreateDescribeGroupedVulResponse() (response *DescribeGroupedVulResponse)

CreateDescribeGroupedVulResponse creates a response to parse from DescribeGroupedVul response

type DescribeImageModifiedRecordsRequest ¶

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

DescribeImageModifiedRecordsRequest is the request struct for api DescribeImageModifiedRecords

func CreateDescribeImageModifiedRecordsRequest ¶

func CreateDescribeImageModifiedRecordsRequest() (request *DescribeImageModifiedRecordsRequest)

CreateDescribeImageModifiedRecordsRequest creates a request to invoke DescribeImageModifiedRecords API

type DescribeImageModifiedRecordsResponse ¶

type DescribeImageModifiedRecordsResponse struct {
	*responses.BaseResponse
	NextToken            string                `json:"NextToken" xml:"NextToken"`
	RequestId            string                `json:"RequestId" xml:"RequestId"`
	TotalCount           int                   `json:"TotalCount" xml:"TotalCount"`
	ImageModifiedRecords []ImageModifiedRecord `json:"ImageModifiedRecords" xml:"ImageModifiedRecords"`
}

DescribeImageModifiedRecordsResponse is the response struct for api DescribeImageModifiedRecords

func CreateDescribeImageModifiedRecordsResponse ¶

func CreateDescribeImageModifiedRecordsResponse() (response *DescribeImageModifiedRecordsResponse)

CreateDescribeImageModifiedRecordsResponse creates a response to parse from DescribeImageModifiedRecords response

type DescribeImagePermissionRequest ¶

type DescribeImagePermissionRequest struct {
	*requests.RpcRequest
	ImageId string `position:"Query" name:"ImageId"`
}

DescribeImagePermissionRequest is the request struct for api DescribeImagePermission

func CreateDescribeImagePermissionRequest ¶

func CreateDescribeImagePermissionRequest() (request *DescribeImagePermissionRequest)

CreateDescribeImagePermissionRequest creates a request to invoke DescribeImagePermission API

type DescribeImagePermissionResponse ¶

type DescribeImagePermissionResponse struct {
	*responses.BaseResponse
	RequestId string   `json:"RequestId" xml:"RequestId"`
	AliUids   []string `json:"AliUids" xml:"AliUids"`
}

DescribeImagePermissionResponse is the response struct for api DescribeImagePermission

func CreateDescribeImagePermissionResponse ¶

func CreateDescribeImagePermissionResponse() (response *DescribeImagePermissionResponse)

CreateDescribeImagePermissionResponse creates a response to parse from DescribeImagePermission response

type DescribeImagesRequest ¶

type DescribeImagesRequest struct {
	*requests.RpcRequest
	ImageId             *[]string        `position:"Query" name:"ImageId"  type:"Repeated"`
	GpuCategory         requests.Boolean `position:"Query" name:"GpuCategory"`
	DesktopInstanceType string           `position:"Query" name:"DesktopInstanceType"`
	LanguageType        string           `position:"Query" name:"LanguageType"`
	NextToken           string           `position:"Query" name:"NextToken"`
	FotaChannel         string           `position:"Query" name:"FotaChannel"`
	ImageType           string           `position:"Query" name:"ImageType"`
	OsType              string           `position:"Query" name:"OsType"`
	ImageStatus         string           `position:"Query" name:"ImageStatus"`
	MaxResults          requests.Integer `position:"Query" name:"MaxResults"`
	ProtocolType        string           `position:"Query" name:"ProtocolType"`
	GpuDriverVersion    string           `position:"Query" name:"GpuDriverVersion"`
}

DescribeImagesRequest is the request struct for api DescribeImages

func CreateDescribeImagesRequest ¶

func CreateDescribeImagesRequest() (request *DescribeImagesRequest)

CreateDescribeImagesRequest creates a request to invoke DescribeImages API

type DescribeImagesResponse ¶

type DescribeImagesResponse struct {
	*responses.BaseResponse
	NextToken string  `json:"NextToken" xml:"NextToken"`
	RequestId string  `json:"RequestId" xml:"RequestId"`
	Images    []Image `json:"Images" xml:"Images"`
}

DescribeImagesResponse is the response struct for api DescribeImages

func CreateDescribeImagesResponse ¶

func CreateDescribeImagesResponse() (response *DescribeImagesResponse)

CreateDescribeImagesResponse creates a response to parse from DescribeImages response

type DescribeInvocationsRequest ¶

type DescribeInvocationsRequest struct {
	*requests.RpcRequest
	InvokeStatus    string           `position:"Query" name:"InvokeStatus"`
	IncludeOutput   requests.Boolean `position:"Query" name:"IncludeOutput"`
	NextToken       string           `position:"Query" name:"NextToken"`
	ContentEncoding string           `position:"Query" name:"ContentEncoding"`
	EndUserId       string           `position:"Query" name:"EndUserId"`
	DesktopId       string           `position:"Query" name:"DesktopId"`
	InvokeId        string           `position:"Query" name:"InvokeId"`
	CommandType     string           `position:"Query" name:"CommandType"`
	MaxResults      requests.Integer `position:"Query" name:"MaxResults"`
}

DescribeInvocationsRequest is the request struct for api DescribeInvocations

func CreateDescribeInvocationsRequest ¶

func CreateDescribeInvocationsRequest() (request *DescribeInvocationsRequest)

CreateDescribeInvocationsRequest creates a request to invoke DescribeInvocations API

type DescribeInvocationsResponse ¶

type DescribeInvocationsResponse struct {
	*responses.BaseResponse
	NextToken   string       `json:"NextToken" xml:"NextToken"`
	RequestId   string       `json:"RequestId" xml:"RequestId"`
	Invocations []Invocation `json:"Invocations" xml:"Invocations"`
}

DescribeInvocationsResponse is the response struct for api DescribeInvocations

func CreateDescribeInvocationsResponse ¶

func CreateDescribeInvocationsResponse() (response *DescribeInvocationsResponse)

CreateDescribeInvocationsResponse creates a response to parse from DescribeInvocations response

type DescribeKmsKeysRequest ¶

type DescribeKmsKeysRequest struct {
	*requests.RpcRequest
}

DescribeKmsKeysRequest is the request struct for api DescribeKmsKeys

func CreateDescribeKmsKeysRequest ¶

func CreateDescribeKmsKeysRequest() (request *DescribeKmsKeysRequest)

CreateDescribeKmsKeysRequest creates a request to invoke DescribeKmsKeys API

type DescribeKmsKeysResponse ¶

type DescribeKmsKeysResponse struct {
	*responses.BaseResponse
	RequestId        string `json:"RequestId" xml:"RequestId"`
	KmsServiceStatus string `json:"KmsServiceStatus" xml:"KmsServiceStatus"`
	AuthorizeStatus  string `json:"AuthorizeStatus" xml:"AuthorizeStatus"`
	Keys             []Key  `json:"Keys" xml:"Keys"`
}

DescribeKmsKeysResponse is the response struct for api DescribeKmsKeys

func CreateDescribeKmsKeysResponse ¶

func CreateDescribeKmsKeysResponse() (response *DescribeKmsKeysResponse)

CreateDescribeKmsKeysResponse creates a response to parse from DescribeKmsKeys response

type DescribeNASFileSystemsRequest ¶

type DescribeNASFileSystemsRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	NextToken    string           `position:"Query" name:"NextToken"`
	MaxResults   requests.Integer `position:"Query" name:"MaxResults"`
	FileSystemId *[]string        `position:"Query" name:"FileSystemId"  type:"Repeated"`
}

DescribeNASFileSystemsRequest is the request struct for api DescribeNASFileSystems

func CreateDescribeNASFileSystemsRequest ¶

func CreateDescribeNASFileSystemsRequest() (request *DescribeNASFileSystemsRequest)

CreateDescribeNASFileSystemsRequest creates a request to invoke DescribeNASFileSystems API

type DescribeNASFileSystemsResponse ¶

type DescribeNASFileSystemsResponse struct {
	*responses.BaseResponse
	NextToken   string       `json:"NextToken" xml:"NextToken"`
	RequestId   string       `json:"RequestId" xml:"RequestId"`
	FileSystems []FileSystem `json:"FileSystems" xml:"FileSystems"`
}

DescribeNASFileSystemsResponse is the response struct for api DescribeNASFileSystems

func CreateDescribeNASFileSystemsResponse ¶

func CreateDescribeNASFileSystemsResponse() (response *DescribeNASFileSystemsResponse)

CreateDescribeNASFileSystemsResponse creates a response to parse from DescribeNASFileSystems response

type DescribeNetworkPackagesRequest ¶

type DescribeNetworkPackagesRequest struct {
	*requests.RpcRequest
	NetworkPackageId   *[]string        `position:"Query" name:"NetworkPackageId"  type:"Repeated"`
	NextToken          string           `position:"Query" name:"NextToken"`
	InternetChargeType string           `position:"Query" name:"InternetChargeType"`
	MaxResults         requests.Integer `position:"Query" name:"MaxResults"`
}

DescribeNetworkPackagesRequest is the request struct for api DescribeNetworkPackages

func CreateDescribeNetworkPackagesRequest ¶

func CreateDescribeNetworkPackagesRequest() (request *DescribeNetworkPackagesRequest)

CreateDescribeNetworkPackagesRequest creates a request to invoke DescribeNetworkPackages API

type DescribeNetworkPackagesResponse ¶

type DescribeNetworkPackagesResponse struct {
	*responses.BaseResponse
	NextToken       string           `json:"NextToken" xml:"NextToken"`
	RequestId       string           `json:"RequestId" xml:"RequestId"`
	NetworkPackages []NetworkPackage `json:"NetworkPackages" xml:"NetworkPackages"`
}

DescribeNetworkPackagesResponse is the response struct for api DescribeNetworkPackages

func CreateDescribeNetworkPackagesResponse ¶

func CreateDescribeNetworkPackagesResponse() (response *DescribeNetworkPackagesResponse)

CreateDescribeNetworkPackagesResponse creates a response to parse from DescribeNetworkPackages response

type DescribeOfficeSitesRequest ¶

type DescribeOfficeSitesRequest struct {
	*requests.RpcRequest
	OfficeSiteId   *[]string        `position:"Query" name:"OfficeSiteId"  type:"Repeated"`
	OfficeSiteType string           `position:"Query" name:"OfficeSiteType"`
	NextToken      string           `position:"Query" name:"NextToken"`
	MaxResults     requests.Integer `position:"Query" name:"MaxResults"`
	Status         string           `position:"Query" name:"Status"`
}

DescribeOfficeSitesRequest is the request struct for api DescribeOfficeSites

func CreateDescribeOfficeSitesRequest ¶

func CreateDescribeOfficeSitesRequest() (request *DescribeOfficeSitesRequest)

CreateDescribeOfficeSitesRequest creates a request to invoke DescribeOfficeSites API

type DescribeOfficeSitesResponse ¶

type DescribeOfficeSitesResponse struct {
	*responses.BaseResponse
	NextToken   string       `json:"NextToken" xml:"NextToken"`
	RequestId   string       `json:"RequestId" xml:"RequestId"`
	OfficeSites []OfficeSite `json:"OfficeSites" xml:"OfficeSites"`
}

DescribeOfficeSitesResponse is the response struct for api DescribeOfficeSites

func CreateDescribeOfficeSitesResponse ¶

func CreateDescribeOfficeSitesResponse() (response *DescribeOfficeSitesResponse)

CreateDescribeOfficeSitesResponse creates a response to parse from DescribeOfficeSites response

type DescribePolicyGroup ¶

type DescribePolicyGroup struct {
	PolicyStatus                 string                        `json:"PolicyStatus" xml:"PolicyStatus"`
	Html5Access                  string                        `json:"Html5Access" xml:"Html5Access"`
	WatermarkType                string                        `json:"WatermarkType" xml:"WatermarkType"`
	PreemptLogin                 string                        `json:"PreemptLogin" xml:"PreemptLogin"`
	WatermarkCustomText          string                        `json:"WatermarkCustomText" xml:"WatermarkCustomText"`
	Clipboard                    string                        `json:"Clipboard" xml:"Clipboard"`
	DomainList                   string                        `json:"DomainList" xml:"DomainList"`
	PolicyGroupId                string                        `json:"PolicyGroupId" xml:"PolicyGroupId"`
	PrinterRedirection           string                        `json:"PrinterRedirection" xml:"PrinterRedirection"`
	WatermarkTransparency        string                        `json:"WatermarkTransparency" xml:"WatermarkTransparency"`
	Html5FileTransfer            string                        `json:"Html5FileTransfer" xml:"Html5FileTransfer"`
	UsbRedirect                  string                        `json:"UsbRedirect" xml:"UsbRedirect"`
	PolicyGroupType              string                        `json:"PolicyGroupType" xml:"PolicyGroupType"`
	Watermark                    string                        `json:"Watermark" xml:"Watermark"`
	VisualQuality                string                        `json:"VisualQuality" xml:"VisualQuality"`
	EdsCount                     int                           `json:"EdsCount" xml:"EdsCount"`
	Name                         string                        `json:"Name" xml:"Name"`
	LocalDrive                   string                        `json:"LocalDrive" xml:"LocalDrive"`
	GpuAcceleration              string                        `json:"GpuAcceleration" xml:"GpuAcceleration"`
	Recording                    string                        `json:"Recording" xml:"Recording"`
	RecordingStartTime           string                        `json:"RecordingStartTime" xml:"RecordingStartTime"`
	RecordingEndTime             string                        `json:"RecordingEndTime" xml:"RecordingEndTime"`
	RecordingFps                 int64                         `json:"RecordingFps" xml:"RecordingFps"`
	CameraRedirect               string                        `json:"CameraRedirect" xml:"CameraRedirect"`
	NetRedirect                  string                        `json:"NetRedirect" xml:"NetRedirect"`
	PreemptLoginUsers            []string                      `json:"PreemptLoginUsers" xml:"PreemptLoginUsers"`
	AuthorizeSecurityPolicyRules []AuthorizeSecurityPolicyRule `json:"AuthorizeSecurityPolicyRules" xml:"AuthorizeSecurityPolicyRules"`
	AuthorizeAccessPolicyRules   []AuthorizeAccessPolicyRule   `json:"AuthorizeAccessPolicyRules" xml:"AuthorizeAccessPolicyRules"`
	ClientTypes                  []ClientType                  `json:"ClientTypes" xml:"ClientTypes"`
	UsbSupplyRedirectRule        []UsbSupplyRedirectRuleItem   `json:"UsbSupplyRedirectRule" xml:"UsbSupplyRedirectRule"`
}

DescribePolicyGroup is a nested struct in ecd response

type DescribePolicyGroups ¶

type DescribePolicyGroups struct {
	DescribePolicyGroup []DescribePolicyGroup `json:"DescribePolicyGroup" xml:"DescribePolicyGroup"`
}

DescribePolicyGroups is a nested struct in ecd response

type DescribePolicyGroupsRequest ¶

type DescribePolicyGroupsRequest struct {
	*requests.RpcRequest
	NextToken     string           `position:"Query" name:"NextToken"`
	MaxResults    requests.Integer `position:"Query" name:"MaxResults"`
	PolicyGroupId *[]string        `position:"Query" name:"PolicyGroupId"  type:"Repeated"`
}

DescribePolicyGroupsRequest is the request struct for api DescribePolicyGroups

func CreateDescribePolicyGroupsRequest ¶

func CreateDescribePolicyGroupsRequest() (request *DescribePolicyGroupsRequest)

CreateDescribePolicyGroupsRequest creates a request to invoke DescribePolicyGroups API

type DescribePolicyGroupsResponse ¶

type DescribePolicyGroupsResponse struct {
	*responses.BaseResponse
	NextToken            string                `json:"NextToken" xml:"NextToken"`
	RequestId            string                `json:"RequestId" xml:"RequestId"`
	DescribePolicyGroups []DescribePolicyGroup `json:"DescribePolicyGroups" xml:"DescribePolicyGroups"`
}

DescribePolicyGroupsResponse is the response struct for api DescribePolicyGroups

func CreateDescribePolicyGroupsResponse ¶

func CreateDescribePolicyGroupsResponse() (response *DescribePolicyGroupsResponse)

CreateDescribePolicyGroupsResponse creates a response to parse from DescribePolicyGroups response

type DescribeRecordingsRequest ¶

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

DescribeRecordingsRequest is the request struct for api DescribeRecordings

func CreateDescribeRecordingsRequest ¶

func CreateDescribeRecordingsRequest() (request *DescribeRecordingsRequest)

CreateDescribeRecordingsRequest creates a request to invoke DescribeRecordings API

type DescribeRecordingsResponse ¶

type DescribeRecordingsResponse struct {
	*responses.BaseResponse
	NextToken  string      `json:"NextToken" xml:"NextToken"`
	RequestId  string      `json:"RequestId" xml:"RequestId"`
	Recordings []Recording `json:"Recordings" xml:"Recordings"`
}

DescribeRecordingsResponse is the response struct for api DescribeRecordings

func CreateDescribeRecordingsResponse ¶

func CreateDescribeRecordingsResponse() (response *DescribeRecordingsResponse)

CreateDescribeRecordingsResponse creates a response to parse from DescribeRecordings response

type DescribeRegionsRequest ¶

type DescribeRegionsRequest struct {
	*requests.RpcRequest
}

DescribeRegionsRequest is the request struct for api DescribeRegions

func CreateDescribeRegionsRequest ¶

func CreateDescribeRegionsRequest() (request *DescribeRegionsRequest)

CreateDescribeRegionsRequest creates a request to invoke DescribeRegions API

type DescribeRegionsResponse ¶

type DescribeRegionsResponse struct {
	*responses.BaseResponse
	RequestId string   `json:"RequestId" xml:"RequestId"`
	Regions   []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 DescribeScanTaskProgressRequest ¶

type DescribeScanTaskProgressRequest struct {
	*requests.RpcRequest
	TaskId requests.Integer `position:"Query" name:"TaskId"`
}

DescribeScanTaskProgressRequest is the request struct for api DescribeScanTaskProgress

func CreateDescribeScanTaskProgressRequest ¶

func CreateDescribeScanTaskProgressRequest() (request *DescribeScanTaskProgressRequest)

CreateDescribeScanTaskProgressRequest creates a request to invoke DescribeScanTaskProgress API

type DescribeScanTaskProgressResponse ¶

type DescribeScanTaskProgressResponse struct {
	*responses.BaseResponse
	RequestId  string `json:"RequestId" xml:"RequestId"`
	TaskStatus string `json:"TaskStatus" xml:"TaskStatus"`
	CreateTime string `json:"CreateTime" xml:"CreateTime"`
}

DescribeScanTaskProgressResponse is the response struct for api DescribeScanTaskProgress

func CreateDescribeScanTaskProgressResponse ¶

func CreateDescribeScanTaskProgressResponse() (response *DescribeScanTaskProgressResponse)

CreateDescribeScanTaskProgressResponse creates a response to parse from DescribeScanTaskProgress response

type DescribeSecurityEventOperationStatusRequest ¶

type DescribeSecurityEventOperationStatusRequest struct {
	*requests.RpcRequest
	SecurityEventId *[]string        `position:"Query" name:"SecurityEventId"  type:"Repeated"`
	TaskId          requests.Integer `position:"Query" name:"TaskId"`
}

DescribeSecurityEventOperationStatusRequest is the request struct for api DescribeSecurityEventOperationStatus

func CreateDescribeSecurityEventOperationStatusRequest ¶

func CreateDescribeSecurityEventOperationStatusRequest() (request *DescribeSecurityEventOperationStatusRequest)

CreateDescribeSecurityEventOperationStatusRequest creates a request to invoke DescribeSecurityEventOperationStatus API

type DescribeSecurityEventOperationStatusResponse ¶

type DescribeSecurityEventOperationStatusResponse struct {
	*responses.BaseResponse
	TaskStatus                     string                         `json:"TaskStatus" xml:"TaskStatus"`
	RequestId                      string                         `json:"RequestId" xml:"RequestId"`
	SecurityEventOperationStatuses []SecurityEventOperationStatus `json:"SecurityEventOperationStatuses" xml:"SecurityEventOperationStatuses"`
}

DescribeSecurityEventOperationStatusResponse is the response struct for api DescribeSecurityEventOperationStatus

func CreateDescribeSecurityEventOperationStatusResponse ¶

func CreateDescribeSecurityEventOperationStatusResponse() (response *DescribeSecurityEventOperationStatusResponse)

CreateDescribeSecurityEventOperationStatusResponse creates a response to parse from DescribeSecurityEventOperationStatus response

type DescribeSecurityEventOperationsRequest ¶

type DescribeSecurityEventOperationsRequest struct {
	*requests.RpcRequest
	SecurityEventId requests.Integer `position:"Query" name:"SecurityEventId"`
}

DescribeSecurityEventOperationsRequest is the request struct for api DescribeSecurityEventOperations

func CreateDescribeSecurityEventOperationsRequest ¶

func CreateDescribeSecurityEventOperationsRequest() (request *DescribeSecurityEventOperationsRequest)

CreateDescribeSecurityEventOperationsRequest creates a request to invoke DescribeSecurityEventOperations API

type DescribeSecurityEventOperationsResponse ¶

type DescribeSecurityEventOperationsResponse struct {
	*responses.BaseResponse
	RequestId               string                   `json:"RequestId" xml:"RequestId"`
	SecurityEventOperations []SecurityEventOperation `json:"SecurityEventOperations" xml:"SecurityEventOperations"`
}

DescribeSecurityEventOperationsResponse is the response struct for api DescribeSecurityEventOperations

func CreateDescribeSecurityEventOperationsResponse ¶

func CreateDescribeSecurityEventOperationsResponse() (response *DescribeSecurityEventOperationsResponse)

CreateDescribeSecurityEventOperationsResponse creates a response to parse from DescribeSecurityEventOperations response

type DescribeSnapshotsRequest ¶

type DescribeSnapshotsRequest struct {
	*requests.RpcRequest
	SnapshotId string           `position:"Query" name:"SnapshotId"`
	NextToken  string           `position:"Query" name:"NextToken"`
	MaxResults requests.Integer `position:"Query" name:"MaxResults"`
	DesktopId  string           `position:"Query" name:"DesktopId"`
}

DescribeSnapshotsRequest is the request struct for api DescribeSnapshots

func CreateDescribeSnapshotsRequest ¶

func CreateDescribeSnapshotsRequest() (request *DescribeSnapshotsRequest)

CreateDescribeSnapshotsRequest creates a request to invoke DescribeSnapshots API

type DescribeSnapshotsResponse ¶

type DescribeSnapshotsResponse struct {
	*responses.BaseResponse
	NextToken string     `json:"NextToken" xml:"NextToken"`
	RequestId string     `json:"RequestId" xml:"RequestId"`
	Snapshots []Snapshot `json:"Snapshots" xml:"Snapshots"`
}

DescribeSnapshotsResponse is the response struct for api DescribeSnapshots

func CreateDescribeSnapshotsResponse ¶

func CreateDescribeSnapshotsResponse() (response *DescribeSnapshotsResponse)

CreateDescribeSnapshotsResponse creates a response to parse from DescribeSnapshots response

type DescribeSuspEventOverviewRequest ¶

type DescribeSuspEventOverviewRequest struct {
	*requests.RpcRequest
}

DescribeSuspEventOverviewRequest is the request struct for api DescribeSuspEventOverview

func CreateDescribeSuspEventOverviewRequest ¶

func CreateDescribeSuspEventOverviewRequest() (request *DescribeSuspEventOverviewRequest)

CreateDescribeSuspEventOverviewRequest creates a request to invoke DescribeSuspEventOverview API

type DescribeSuspEventOverviewResponse ¶

type DescribeSuspEventOverviewResponse struct {
	*responses.BaseResponse
	SuspiciousCount int    `json:"SuspiciousCount" xml:"SuspiciousCount"`
	RemindCount     int    `json:"RemindCount" xml:"RemindCount"`
	SeriousCount    int    `json:"SeriousCount" xml:"SeriousCount"`
	RequestId       string `json:"RequestId" xml:"RequestId"`
}

DescribeSuspEventOverviewResponse is the response struct for api DescribeSuspEventOverview

func CreateDescribeSuspEventOverviewResponse ¶

func CreateDescribeSuspEventOverviewResponse() (response *DescribeSuspEventOverviewResponse)

CreateDescribeSuspEventOverviewResponse creates a response to parse from DescribeSuspEventOverview response

type DescribeSuspEventQuaraFilesRequest ¶

type DescribeSuspEventQuaraFilesRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	CurrentPage  requests.Integer `position:"Query" name:"CurrentPage"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	Status       string           `position:"Query" name:"Status"`
}

DescribeSuspEventQuaraFilesRequest is the request struct for api DescribeSuspEventQuaraFiles

func CreateDescribeSuspEventQuaraFilesRequest ¶

func CreateDescribeSuspEventQuaraFilesRequest() (request *DescribeSuspEventQuaraFilesRequest)

CreateDescribeSuspEventQuaraFilesRequest creates a request to invoke DescribeSuspEventQuaraFiles API

type DescribeSuspEventQuaraFilesResponse ¶

type DescribeSuspEventQuaraFilesResponse struct {
	*responses.BaseResponse
	CurrentPage int         `json:"CurrentPage" xml:"CurrentPage"`
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	PageSize    int         `json:"PageSize" xml:"PageSize"`
	TotalCount  int         `json:"TotalCount" xml:"TotalCount"`
	QuaraFiles  []QuaraFile `json:"QuaraFiles" xml:"QuaraFiles"`
}

DescribeSuspEventQuaraFilesResponse is the response struct for api DescribeSuspEventQuaraFiles

func CreateDescribeSuspEventQuaraFilesResponse ¶

func CreateDescribeSuspEventQuaraFilesResponse() (response *DescribeSuspEventQuaraFilesResponse)

CreateDescribeSuspEventQuaraFilesResponse creates a response to parse from DescribeSuspEventQuaraFiles response

type DescribeSuspEventsRequest ¶

type DescribeSuspEventsRequest struct {
	*requests.RpcRequest
	OfficeSiteId    string           `position:"Query" name:"OfficeSiteId"`
	AlarmUniqueInfo string           `position:"Query" name:"AlarmUniqueInfo"`
	Dealed          string           `position:"Query" name:"Dealed"`
	CurrentPage     requests.Integer `position:"Query" name:"CurrentPage"`
	PageSize        requests.Integer `position:"Query" name:"PageSize"`
	ParentEventType string           `position:"Query" name:"ParentEventType"`
	Lang            string           `position:"Query" name:"Lang"`
	Levels          string           `position:"Query" name:"Levels"`
}

DescribeSuspEventsRequest is the request struct for api DescribeSuspEvents

func CreateDescribeSuspEventsRequest ¶

func CreateDescribeSuspEventsRequest() (request *DescribeSuspEventsRequest)

CreateDescribeSuspEventsRequest creates a request to invoke DescribeSuspEvents API

type DescribeSuspEventsResponse ¶

type DescribeSuspEventsResponse struct {
	*responses.BaseResponse
	CurrentPage int         `json:"CurrentPage" xml:"CurrentPage"`
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	PageSize    string      `json:"PageSize" xml:"PageSize"`
	TotalCount  int         `json:"TotalCount" xml:"TotalCount"`
	SuspEvents  []SuspEvent `json:"SuspEvents" xml:"SuspEvents"`
}

DescribeSuspEventsResponse is the response struct for api DescribeSuspEvents

func CreateDescribeSuspEventsResponse ¶

func CreateDescribeSuspEventsResponse() (response *DescribeSuspEventsResponse)

CreateDescribeSuspEventsResponse creates a response to parse from DescribeSuspEvents response

type DescribeUserConnectionRecordsRequest ¶

type DescribeUserConnectionRecordsRequest struct {
	*requests.RpcRequest
	ConnectEndTimeFrom   requests.Integer `position:"Query" name:"ConnectEndTimeFrom"`
	ConnectDurationFrom  requests.Integer `position:"Query" name:"ConnectDurationFrom"`
	ConnectDurationTo    requests.Integer `position:"Query" name:"ConnectDurationTo"`
	EndUserType          string           `position:"Query" name:"EndUserType"`
	DesktopGroupId       string           `position:"Query" name:"DesktopGroupId"`
	NextToken            string           `position:"Query" name:"NextToken"`
	ConnectStartTimeFrom requests.Integer `position:"Query" name:"ConnectStartTimeFrom"`
	EndUserId            string           `position:"Query" name:"EndUserId"`
	DesktopId            string           `position:"Query" name:"DesktopId"`
	ConnectEndTimeTo     requests.Integer `position:"Query" name:"ConnectEndTimeTo"`
	ConnectStartTimeTo   requests.Integer `position:"Query" name:"ConnectStartTimeTo"`
	MaxResults           requests.Integer `position:"Query" name:"MaxResults"`
}

DescribeUserConnectionRecordsRequest is the request struct for api DescribeUserConnectionRecords

func CreateDescribeUserConnectionRecordsRequest ¶

func CreateDescribeUserConnectionRecordsRequest() (request *DescribeUserConnectionRecordsRequest)

CreateDescribeUserConnectionRecordsRequest creates a request to invoke DescribeUserConnectionRecords API

type DescribeUserConnectionRecordsResponse ¶

type DescribeUserConnectionRecordsResponse struct {
	*responses.BaseResponse
	NextToken         string             `json:"NextToken" xml:"NextToken"`
	RequestId         string             `json:"RequestId" xml:"RequestId"`
	ConnectionRecords []ConnectionRecord `json:"ConnectionRecords" xml:"ConnectionRecords"`
}

DescribeUserConnectionRecordsResponse is the response struct for api DescribeUserConnectionRecords

func CreateDescribeUserConnectionRecordsResponse ¶

func CreateDescribeUserConnectionRecordsResponse() (response *DescribeUserConnectionRecordsResponse)

CreateDescribeUserConnectionRecordsResponse creates a response to parse from DescribeUserConnectionRecords response

type DescribeUsersInGroupRequest ¶

type DescribeUsersInGroupRequest struct {
	*requests.RpcRequest
	ConnectState    requests.Integer `position:"Query" name:"ConnectState"`
	Filter          string           `position:"Query" name:"Filter"`
	DesktopGroupId  string           `position:"Query" name:"DesktopGroupId"`
	NextToken       string           `position:"Query" name:"NextToken"`
	QueryUserDetail requests.Boolean `position:"Query" name:"QueryUserDetail"`
	MaxResults      requests.Integer `position:"Query" name:"MaxResults"`
	EndUserId       string           `position:"Query" name:"EndUserId"`
}

DescribeUsersInGroupRequest is the request struct for api DescribeUsersInGroup

func CreateDescribeUsersInGroupRequest ¶

func CreateDescribeUsersInGroupRequest() (request *DescribeUsersInGroupRequest)

CreateDescribeUsersInGroupRequest creates a request to invoke DescribeUsersInGroup API

type DescribeUsersInGroupResponse ¶

type DescribeUsersInGroupResponse struct {
	*responses.BaseResponse
	NextToken        string    `json:"NextToken" xml:"NextToken"`
	RequestId        string    `json:"RequestId" xml:"RequestId"`
	UsersCount       int       `json:"UsersCount" xml:"UsersCount"`
	OnlineUsersCount int       `json:"OnlineUsersCount" xml:"OnlineUsersCount"`
	EndUsers         []EndUser `json:"EndUsers" xml:"EndUsers"`
}

DescribeUsersInGroupResponse is the response struct for api DescribeUsersInGroup

func CreateDescribeUsersInGroupResponse ¶

func CreateDescribeUsersInGroupResponse() (response *DescribeUsersInGroupResponse)

CreateDescribeUsersInGroupResponse creates a response to parse from DescribeUsersInGroup response

type DescribeVirtualMFADevicesRequest ¶

type DescribeVirtualMFADevicesRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	NextToken    string           `position:"Query" name:"NextToken"`
	MaxResults   requests.Integer `position:"Query" name:"MaxResults"`
	DirectoryId  string           `position:"Query" name:"DirectoryId"`
	EndUserId    *[]string        `position:"Query" name:"EndUserId"  type:"Repeated"`
}

DescribeVirtualMFADevicesRequest is the request struct for api DescribeVirtualMFADevices

func CreateDescribeVirtualMFADevicesRequest ¶

func CreateDescribeVirtualMFADevicesRequest() (request *DescribeVirtualMFADevicesRequest)

CreateDescribeVirtualMFADevicesRequest creates a request to invoke DescribeVirtualMFADevices API

type DescribeVirtualMFADevicesResponse ¶

type DescribeVirtualMFADevicesResponse struct {
	*responses.BaseResponse
	NextToken         string             `json:"NextToken" xml:"NextToken"`
	RequestId         string             `json:"RequestId" xml:"RequestId"`
	VirtualMFADevices []VirtualMFADevice `json:"VirtualMFADevices" xml:"VirtualMFADevices"`
}

DescribeVirtualMFADevicesResponse is the response struct for api DescribeVirtualMFADevices

func CreateDescribeVirtualMFADevicesResponse ¶

func CreateDescribeVirtualMFADevicesResponse() (response *DescribeVirtualMFADevicesResponse)

CreateDescribeVirtualMFADevicesResponse creates a response to parse from DescribeVirtualMFADevices response

type DescribeVulDetailsRequest ¶

type DescribeVulDetailsRequest struct {
	*requests.RpcRequest
	Type      string `position:"Query" name:"Type"`
	AliasName string `position:"Query" name:"AliasName"`
	Name      string `position:"Query" name:"Name"`
	Lang      string `position:"Query" name:"Lang"`
}

DescribeVulDetailsRequest is the request struct for api DescribeVulDetails

func CreateDescribeVulDetailsRequest ¶

func CreateDescribeVulDetailsRequest() (request *DescribeVulDetailsRequest)

CreateDescribeVulDetailsRequest creates a request to invoke DescribeVulDetails API

type DescribeVulDetailsResponse ¶

type DescribeVulDetailsResponse struct {
	*responses.BaseResponse
	RequestId string `json:"RequestId" xml:"RequestId"`
	Cves      []Cve  `json:"Cves" xml:"Cves"`
}

DescribeVulDetailsResponse is the response struct for api DescribeVulDetails

func CreateDescribeVulDetailsResponse ¶

func CreateDescribeVulDetailsResponse() (response *DescribeVulDetailsResponse)

CreateDescribeVulDetailsResponse creates a response to parse from DescribeVulDetails response

type DescribeVulListRequest ¶

type DescribeVulListRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	Dealed       string           `position:"Query" name:"Dealed"`
	CurrentPage  requests.Integer `position:"Query" name:"CurrentPage"`
	Type         string           `position:"Query" name:"Type"`
	AliasName    string           `position:"Query" name:"AliasName"`
	PageSize     requests.Integer `position:"Query" name:"PageSize"`
	Lang         string           `position:"Query" name:"Lang"`
	Necessity    string           `position:"Query" name:"Necessity"`
}

DescribeVulListRequest is the request struct for api DescribeVulList

func CreateDescribeVulListRequest ¶

func CreateDescribeVulListRequest() (request *DescribeVulListRequest)

CreateDescribeVulListRequest creates a request to invoke DescribeVulList API

type DescribeVulListResponse ¶

type DescribeVulListResponse struct {
	*responses.BaseResponse
	CurrentPage int         `json:"CurrentPage" xml:"CurrentPage"`
	RequestId   string      `json:"RequestId" xml:"RequestId"`
	PageSize    int         `json:"PageSize" xml:"PageSize"`
	TotalCount  int         `json:"TotalCount" xml:"TotalCount"`
	VulRecords  []VulRecord `json:"VulRecords" xml:"VulRecords"`
}

DescribeVulListResponse is the response struct for api DescribeVulList

func CreateDescribeVulListResponse ¶

func CreateDescribeVulListResponse() (response *DescribeVulListResponse)

CreateDescribeVulListResponse creates a response to parse from DescribeVulList response

type DescribeVulOverviewRequest ¶

type DescribeVulOverviewRequest struct {
	*requests.RpcRequest
}

DescribeVulOverviewRequest is the request struct for api DescribeVulOverview

func CreateDescribeVulOverviewRequest ¶

func CreateDescribeVulOverviewRequest() (request *DescribeVulOverviewRequest)

CreateDescribeVulOverviewRequest creates a request to invoke DescribeVulOverview API

type DescribeVulOverviewResponse ¶

type DescribeVulOverviewResponse struct {
	*responses.BaseResponse
	NntfCount  int    `json:"NntfCount" xml:"NntfCount"`
	LaterCount int    `json:"LaterCount" xml:"LaterCount"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
	AsapCount  int    `json:"AsapCount" xml:"AsapCount"`
}

DescribeVulOverviewResponse is the response struct for api DescribeVulOverview

func CreateDescribeVulOverviewResponse ¶

func CreateDescribeVulOverviewResponse() (response *DescribeVulOverviewResponse)

CreateDescribeVulOverviewResponse creates a response to parse from DescribeVulOverview response

type DescribeZonesRequest ¶

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

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"`
	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 Desktop ¶

type Desktop struct {
	CreationTime            string     `json:"CreationTime" xml:"CreationTime"`
	ChargeType              string     `json:"ChargeType" xml:"ChargeType"`
	DesktopName             string     `json:"DesktopName" xml:"DesktopName"`
	PolicyGroupName         string     `json:"PolicyGroupName" xml:"PolicyGroupName"`
	SystemDiskSize          int        `json:"SystemDiskSize" xml:"SystemDiskSize"`
	PolicyGroupId           string     `json:"PolicyGroupId" xml:"PolicyGroupId"`
	DesktopStatus           string     `json:"DesktopStatus" xml:"DesktopStatus"`
	DesktopType             string     `json:"DesktopType" xml:"DesktopType"`
	GpuCount                float64    `json:"GpuCount" xml:"GpuCount"`
	ProtocolType            string     `json:"ProtocolType" xml:"ProtocolType"`
	Memory                  int64      `json:"Memory" xml:"Memory"`
	GpuSpec                 string     `json:"GpuSpec" xml:"GpuSpec"`
	ImageId                 string     `json:"ImageId" xml:"ImageId"`
	DirectoryId             string     `json:"DirectoryId" xml:"DirectoryId"`
	ManagementFlag          string     `json:"ManagementFlag" xml:"ManagementFlag"`
	DataDiskCategory        string     `json:"DataDiskCategory" xml:"DataDiskCategory"`
	SystemDiskCategory      string     `json:"SystemDiskCategory" xml:"SystemDiskCategory"`
	NetworkInterfaceId      string     `json:"NetworkInterfaceId" xml:"NetworkInterfaceId"`
	OfficeSiteId            string     `json:"OfficeSiteId" xml:"OfficeSiteId"`
	DataDiskSize            string     `json:"DataDiskSize" xml:"DataDiskSize"`
	DesktopGroupId          string     `json:"DesktopGroupId" xml:"DesktopGroupId"`
	DesktopId               string     `json:"DesktopId" xml:"DesktopId"`
	OfficeSiteName          string     `json:"OfficeSiteName" xml:"OfficeSiteName"`
	StartTime               string     `json:"StartTime" xml:"StartTime"`
	DirectoryType           string     `json:"DirectoryType" xml:"DirectoryType"`
	Cpu                     int        `json:"Cpu" xml:"Cpu"`
	NetworkInterfaceIp      string     `json:"NetworkInterfaceIp" xml:"NetworkInterfaceIp"`
	ExpiredTime             string     `json:"ExpiredTime" xml:"ExpiredTime"`
	OsType                  string     `json:"OsType" xml:"OsType"`
	ConnectionStatus        string     `json:"ConnectionStatus" xml:"ConnectionStatus"`
	BundleId                string     `json:"BundleId" xml:"BundleId"`
	BundleName              string     `json:"BundleName" xml:"BundleName"`
	OfficeSiteType          string     `json:"OfficeSiteType" xml:"OfficeSiteType"`
	HostName                string     `json:"HostName" xml:"HostName"`
	DowngradeQuota          int64      `json:"DowngradeQuota" xml:"DowngradeQuota"`
	DowngradedTimes         int64      `json:"DowngradedTimes" xml:"DowngradedTimes"`
	GpuCategory             int64      `json:"GpuCategory" xml:"GpuCategory"`
	GpuDriverVersion        string     `json:"GpuDriverVersion" xml:"GpuDriverVersion"`
	ZoneType                string     `json:"ZoneType" xml:"ZoneType"`
	Progress                string     `json:"Progress" xml:"Progress"`
	VolumeEncryptionEnabled bool       `json:"VolumeEncryptionEnabled" xml:"VolumeEncryptionEnabled"`
	VolumeEncryptionKey     string     `json:"VolumeEncryptionKey" xml:"VolumeEncryptionKey"`
	OfficeSiteVpcType       string     `json:"OfficeSiteVpcType" xml:"OfficeSiteVpcType"`
	Platform                string     `json:"Platform" xml:"Platform"`
	SessionType             string     `json:"SessionType" xml:"SessionType"`
	EndUserIds              []string   `json:"EndUserIds" xml:"EndUserIds"`
	FotaUpdate              FotaUpdate `json:"FotaUpdate" xml:"FotaUpdate"`
	Disks                   []Disk     `json:"Disks" xml:"Disks"`
	Tags                    []Tag      `json:"Tags" xml:"Tags"`
	Sessions                []Session  `json:"Sessions" xml:"Sessions"`
}

Desktop is a nested struct in ecd response

type DesktopFlowStatistic ¶

type DesktopFlowStatistic struct {
	FlowStatistic []FlowStatistic `json:"FlowStatistic" xml:"FlowStatistic"`
}

DesktopFlowStatistic is a nested struct in ecd response

type DesktopGroup ¶

type DesktopGroup struct {
	CreateTime              string  `json:"CreateTime" xml:"CreateTime"`
	PayType                 string  `json:"PayType" xml:"PayType"`
	PolicyGroupName         string  `json:"PolicyGroupName" xml:"PolicyGroupName"`
	Creator                 string  `json:"Creator" xml:"Creator"`
	MaxDesktopsCount        int     `json:"MaxDesktopsCount" xml:"MaxDesktopsCount"`
	SystemDiskSize          int     `json:"SystemDiskSize" xml:"SystemDiskSize"`
	PolicyGroupId           string  `json:"PolicyGroupId" xml:"PolicyGroupId"`
	OwnBundleId             string  `json:"OwnBundleId" xml:"OwnBundleId"`
	GpuCount                float64 `json:"GpuCount" xml:"GpuCount"`
	Memory                  int64   `json:"Memory" xml:"Memory"`
	GpuSpec                 string  `json:"GpuSpec" xml:"GpuSpec"`
	DirectoryId             string  `json:"DirectoryId" xml:"DirectoryId"`
	OwnBundleName           string  `json:"OwnBundleName" xml:"OwnBundleName"`
	DataDiskCategory        string  `json:"DataDiskCategory" xml:"DataDiskCategory"`
	DesktopGroupName        string  `json:"DesktopGroupName" xml:"DesktopGroupName"`
	SystemDiskCategory      string  `json:"SystemDiskCategory" xml:"SystemDiskCategory"`
	OfficeSiteId            string  `json:"OfficeSiteId" xml:"OfficeSiteId"`
	KeepDuration            int64   `json:"KeepDuration" xml:"KeepDuration"`
	MinDesktopsCount        int     `json:"MinDesktopsCount" xml:"MinDesktopsCount"`
	EndUserCount            int     `json:"EndUserCount" xml:"EndUserCount"`
	DataDiskSize            string  `json:"DataDiskSize" xml:"DataDiskSize"`
	DesktopGroupId          string  `json:"DesktopGroupId" xml:"DesktopGroupId"`
	OfficeSiteName          string  `json:"OfficeSiteName" xml:"OfficeSiteName"`
	DirectoryType           string  `json:"DirectoryType" xml:"DirectoryType"`
	Cpu                     int     `json:"Cpu" xml:"Cpu"`
	ExpiredTime             string  `json:"ExpiredTime" xml:"ExpiredTime"`
	Comments                string  `json:"Comments" xml:"Comments"`
	OfficeSiteType          string  `json:"OfficeSiteType" xml:"OfficeSiteType"`
	Status                  int     `json:"Status" xml:"Status"`
	ResetType               int64   `json:"ResetType" xml:"ResetType"`
	LoadPolicy              int64   `json:"LoadPolicy" xml:"LoadPolicy"`
	BindAmount              int64   `json:"BindAmount" xml:"BindAmount"`
	OwnType                 int64   `json:"OwnType" xml:"OwnType"`
	ImageId                 string  `json:"ImageId" xml:"ImageId"`
	VolumeEncryptionEnabled bool    `json:"VolumeEncryptionEnabled" xml:"VolumeEncryptionEnabled"`
	VolumeEncryptionKey     string  `json:"VolumeEncryptionKey" xml:"VolumeEncryptionKey"`
}

DesktopGroup is a nested struct in ecd response

type DesktopGroups ¶

type DesktopGroups struct {
	DesktopGroup []DesktopGroup `json:"DesktopGroup" xml:"DesktopGroup"`
}

DesktopGroups is a nested struct in ecd response

type DesktopIdInCreateDesktops ¶

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

DesktopIdInCreateDesktops is a nested struct in ecd response

type DesktopIdInModifyDesktopChargeType ¶

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

DesktopIdInModifyDesktopChargeType is a nested struct in ecd response

type DesktopItem ¶

type DesktopItem struct {
	DesktopName string `json:"DesktopName" xml:"DesktopName"`
	DesktopId   string `json:"DesktopId" xml:"DesktopId"`
}

DesktopItem is a nested struct in ecd response

type DesktopItems ¶

type DesktopItems struct {
	DesktopItem []DesktopItem `json:"DesktopItem" xml:"DesktopItem"`
}

DesktopItems is a nested struct in ecd response

type DesktopType ¶

type DesktopType struct {
	SystemDiskSize     string              `json:"SystemDiskSize" xml:"SystemDiskSize"`
	DesktopTypeId      string              `json:"DesktopTypeId" xml:"DesktopTypeId"`
	DataDiskSize       string              `json:"DataDiskSize" xml:"DataDiskSize"`
	CpuCount           string              `json:"CpuCount" xml:"CpuCount"`
	GpuCount           float64             `json:"GpuCount" xml:"GpuCount"`
	GpuSpec            string              `json:"GpuSpec" xml:"GpuSpec"`
	InstanceTypeFamily string              `json:"InstanceTypeFamily" xml:"InstanceTypeFamily"`
	MemorySize         string              `json:"MemorySize" xml:"MemorySize"`
	DesktopTypeStatus  string              `json:"DesktopTypeStatus" xml:"DesktopTypeStatus"`
	AllowDiskSize      []AllowDiskSizeItem `json:"AllowDiskSize" xml:"AllowDiskSize"`
}

DesktopType is a nested struct in ecd response

type DesktopTypeAttribute ¶

type DesktopTypeAttribute struct {
	CpuCount   int     `json:"CpuCount" xml:"CpuCount"`
	GpuCount   float64 `json:"GpuCount" xml:"GpuCount"`
	GpuSpec    string  `json:"GpuSpec" xml:"GpuSpec"`
	MemorySize int     `json:"MemorySize" xml:"MemorySize"`
}

DesktopTypeAttribute is a nested struct in ecd response

type DesktopTypes ¶

type DesktopTypes struct {
	DesktopType []DesktopType `json:"DesktopType" xml:"DesktopType"`
}

DesktopTypes is a nested struct in ecd response

type Desktops ¶

type Desktops struct {
	GpuSpec            string      `json:"GpuSpec" xml:"GpuSpec"`
	Comments           string      `json:"Comments" xml:"Comments"`
	DesktopGroupName   string      `json:"DesktopGroupName" xml:"DesktopGroupName"`
	SystemDiskSize     int         `json:"SystemDiskSize" xml:"SystemDiskSize"`
	OfficeSiteName     string      `json:"OfficeSiteName" xml:"OfficeSiteName"`
	MaxDesktopsCount   int         `json:"MaxDesktopsCount" xml:"MaxDesktopsCount"`
	AllowAutoSetup     int         `json:"AllowAutoSetup" xml:"AllowAutoSetup"`
	Creator            string      `json:"Creator" xml:"Creator"`
	MinDesktopsCount   int         `json:"MinDesktopsCount" xml:"MinDesktopsCount"`
	BindAmount         int         `json:"BindAmount" xml:"BindAmount"`
	LoadPolicy         int         `json:"LoadPolicy" xml:"LoadPolicy"`
	DirectoryId        string      `json:"DirectoryId" xml:"DirectoryId"`
	Status             int         `json:"Status" xml:"Status"`
	ExpiredTime        string      `json:"ExpiredTime" xml:"ExpiredTime"`
	PayType            string      `json:"PayType" xml:"PayType"`
	OwnBundleName      string      `json:"OwnBundleName" xml:"OwnBundleName"`
	KeepDuration       int64       `json:"KeepDuration" xml:"KeepDuration"`
	CreationTime       string      `json:"CreationTime" xml:"CreationTime"`
	Memory             int64       `json:"Memory" xml:"Memory"`
	DesktopGroupId     string      `json:"DesktopGroupId" xml:"DesktopGroupId"`
	OfficeSiteId       string      `json:"OfficeSiteId" xml:"OfficeSiteId"`
	DataDiskSize       string      `json:"DataDiskSize" xml:"DataDiskSize"`
	ResType            int         `json:"ResType" xml:"ResType"`
	PolicyGroupName    string      `json:"PolicyGroupName" xml:"PolicyGroupName"`
	DirectoryType      string      `json:"DirectoryType" xml:"DirectoryType"`
	GpuCount           float64     `json:"GpuCount" xml:"GpuCount"`
	OwnBundleId        string      `json:"OwnBundleId" xml:"OwnBundleId"`
	AllowBufferCount   int         `json:"AllowBufferCount" xml:"AllowBufferCount"`
	OwnType            int         `json:"OwnType" xml:"OwnType"`
	OfficeSiteType     string      `json:"OfficeSiteType" xml:"OfficeSiteType"`
	ResetType          int         `json:"ResetType" xml:"ResetType"`
	PolicyGroupId      string      `json:"PolicyGroupId" xml:"PolicyGroupId"`
	SystemDiskCategory string      `json:"SystemDiskCategory" xml:"SystemDiskCategory"`
	Cpu                int         `json:"Cpu" xml:"Cpu"`
	DataDiskCategory   string      `json:"DataDiskCategory" xml:"DataDiskCategory"`
	TimerInfos         []TimerInfo `json:"TimerInfos" xml:"TimerInfos"`
}

Desktops is a nested struct in ecd response

type DesktopsInDescribeDesktops ¶

type DesktopsInDescribeDesktops struct {
	Desktop []Desktop `json:"Desktop" xml:"Desktop"`
}

DesktopsInDescribeDesktops is a nested struct in ecd response

type DetachCenRequest ¶

type DetachCenRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
}

DetachCenRequest is the request struct for api DetachCen

func CreateDetachCenRequest ¶

func CreateDetachCenRequest() (request *DetachCenRequest)

CreateDetachCenRequest creates a request to invoke DetachCen API

type DetachCenResponse ¶

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

DetachCenResponse is the response struct for api DetachCen

func CreateDetachCenResponse ¶

func CreateDetachCenResponse() (response *DetachCenResponse)

CreateDetachCenResponse creates a response to parse from DetachCen response

type Detail ¶

type Detail struct {
	Type         string `json:"Type" xml:"Type"`
	Value        string `json:"Value" xml:"Value"`
	NameDisplay  string `json:"NameDisplay" xml:"NameDisplay"`
	Name         string `json:"Name" xml:"Name"`
	ValueDisplay string `json:"ValueDisplay" xml:"ValueDisplay"`
}

Detail is a nested struct in ecd response

type Details ¶

type Details struct {
	Detail []Detail `json:"Detail" xml:"Detail"`
}

Details is a nested struct in ecd response

type Directories ¶

type Directories struct {
	Directory []Directory `json:"Directory" xml:"Directory"`
}

Directories is a nested struct in ecd response

type Directory ¶

type Directory struct {
	EnableInternetAccess     bool          `json:"EnableInternetAccess" xml:"EnableInternetAccess"`
	VpcId                    string        `json:"VpcId" xml:"VpcId"`
	CreationTime             string        `json:"CreationTime" xml:"CreationTime"`
	Status                   string        `json:"Status" xml:"Status"`
	DomainPassword           string        `json:"DomainPassword" xml:"DomainPassword"`
	EnableAdminAccess        bool          `json:"EnableAdminAccess" xml:"EnableAdminAccess"`
	SubDomainName            string        `json:"SubDomainName" xml:"SubDomainName"`
	DomainUserName           string        `json:"DomainUserName" xml:"DomainUserName"`
	EnableCrossDesktopAccess bool          `json:"EnableCrossDesktopAccess" xml:"EnableCrossDesktopAccess"`
	CustomSecurityGroupId    string        `json:"CustomSecurityGroupId" xml:"CustomSecurityGroupId"`
	DesktopVpcEndpoint       string        `json:"DesktopVpcEndpoint" xml:"DesktopVpcEndpoint"`
	SsoEnabled               bool          `json:"SsoEnabled" xml:"SsoEnabled"`
	DomainName               string        `json:"DomainName" xml:"DomainName"`
	DesktopAccessType        string        `json:"DesktopAccessType" xml:"DesktopAccessType"`
	MfaEnabled               bool          `json:"MfaEnabled" xml:"MfaEnabled"`
	DirectoryType            string        `json:"DirectoryType" xml:"DirectoryType"`
	DnsUserName              string        `json:"DnsUserName" xml:"DnsUserName"`
	TrustPassword            string        `json:"TrustPassword" xml:"TrustPassword"`
	OuName                   string        `json:"OuName" xml:"OuName"`
	Name                     string        `json:"Name" xml:"Name"`
	DirectoryId              string        `json:"DirectoryId" xml:"DirectoryId"`
	NeedVerifyLoginRisk      bool          `json:"NeedVerifyLoginRisk" xml:"NeedVerifyLoginRisk"`
	VSwitchIds               []string      `json:"VSwitchIds" xml:"VSwitchIds"`
	FileSystemIds            []string      `json:"FileSystemIds" xml:"FileSystemIds"`
	SubDnsAddress            []string      `json:"SubDnsAddress" xml:"SubDnsAddress"`
	DnsAddress               []string      `json:"DnsAddress" xml:"DnsAddress"`
	ADConnectors             []ADConnector `json:"ADConnectors" xml:"ADConnectors"`
	Logs                     []Log         `json:"Logs" xml:"Logs"`
}

Directory is a nested struct in ecd response

type DisableDesktopsInGroupRequest ¶

type DisableDesktopsInGroupRequest struct {
	*requests.RpcRequest
	DesktopIds     *[]string `position:"Query" name:"DesktopIds"  type:"Repeated"`
	DesktopGroupId string    `position:"Query" name:"DesktopGroupId"`
}

DisableDesktopsInGroupRequest is the request struct for api DisableDesktopsInGroup

func CreateDisableDesktopsInGroupRequest ¶

func CreateDisableDesktopsInGroupRequest() (request *DisableDesktopsInGroupRequest)

CreateDisableDesktopsInGroupRequest creates a request to invoke DisableDesktopsInGroup API

type DisableDesktopsInGroupResponse ¶

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

DisableDesktopsInGroupResponse is the response struct for api DisableDesktopsInGroup

func CreateDisableDesktopsInGroupResponse ¶

func CreateDisableDesktopsInGroupResponse() (response *DisableDesktopsInGroupResponse)

CreateDisableDesktopsInGroupResponse creates a response to parse from DisableDesktopsInGroup response

type Disk ¶

type Disk struct {
	DiskType             string `json:"DiskType" xml:"DiskType"`
	DiskPerformanceLevel string `json:"DiskPerformanceLevel" xml:"DiskPerformanceLevel"`
	DiskSize             int    `json:"DiskSize" xml:"DiskSize"`
	PerformanceLevel     string `json:"PerformanceLevel" xml:"PerformanceLevel"`
	DiskId               string `json:"DiskId" xml:"DiskId"`
}

Disk is a nested struct in ecd response

type DisksInDescribeBundles ¶

type DisksInDescribeBundles struct {
	Disk []Disk `json:"Disk" xml:"Disk"`
}

DisksInDescribeBundles is a nested struct in ecd response

type DisksInDescribeDesktops ¶

type DisksInDescribeDesktops struct {
	Disk []Disk `json:"Disk" xml:"Disk"`
}

DisksInDescribeDesktops is a nested struct in ecd response

type DissociateNetworkPackageRequest ¶

type DissociateNetworkPackageRequest struct {
	*requests.RpcRequest
	NetworkPackageId string `position:"Query" name:"NetworkPackageId"`
}

DissociateNetworkPackageRequest is the request struct for api DissociateNetworkPackage

func CreateDissociateNetworkPackageRequest ¶

func CreateDissociateNetworkPackageRequest() (request *DissociateNetworkPackageRequest)

CreateDissociateNetworkPackageRequest creates a request to invoke DissociateNetworkPackage API

type DissociateNetworkPackageResponse ¶

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

DissociateNetworkPackageResponse is the response struct for api DissociateNetworkPackage

func CreateDissociateNetworkPackageResponse ¶

func CreateDissociateNetworkPackageResponse() (response *DissociateNetworkPackageResponse)

CreateDissociateNetworkPackageResponse creates a response to parse from DissociateNetworkPackage response

type DnsAddressInDescribeDirectories ¶

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

DnsAddressInDescribeDirectories is a nested struct in ecd response

type DnsAddressInDescribeOfficeSites ¶

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

DnsAddressInDescribeOfficeSites is a nested struct in ecd response

type EipAddresses ¶

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

EipAddresses is a nested struct in ecd response

type EndUser ¶

type EndUser struct {
	EndUserId               string                    `json:"EndUserId" xml:"EndUserId"`
	EndUserEmail            string                    `json:"EndUserEmail" xml:"EndUserEmail"`
	DesktopName             string                    `json:"DesktopName" xml:"DesktopName"`
	ConnectionStatus        string                    `json:"ConnectionStatus" xml:"ConnectionStatus"`
	DesktopId               string                    `json:"DesktopId" xml:"DesktopId"`
	EndUserType             string                    `json:"EndUserType" xml:"EndUserType"`
	EndUserPhone            string                    `json:"EndUserPhone" xml:"EndUserPhone"`
	EndUserName             string                    `json:"EndUserName" xml:"EndUserName"`
	ExternalInfo            ExternalInfo              `json:"ExternalInfo" xml:"ExternalInfo"`
	UserSetPropertiesModels []UserSetPropertiesModels `json:"UserSetPropertiesModels" xml:"UserSetPropertiesModels"`
}

EndUser is a nested struct in ecd response

type EndUserIdsInDescribeDesktops ¶

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

EndUserIdsInDescribeDesktops is a nested struct in ecd response

type EndUserIdsInDescribeDesktopsInGroup ¶

type EndUserIdsInDescribeDesktopsInGroup struct {
	EndUserIds []string `json:"endUserIds" xml:"endUserIds"`
}

EndUserIdsInDescribeDesktopsInGroup is a nested struct in ecd response

type EndUserIdsInDescribeRecordings ¶

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

EndUserIdsInDescribeRecordings is a nested struct in ecd response

type EndUserNamesInDescribeDesktopsInGroup ¶

type EndUserNamesInDescribeDesktopsInGroup struct {
	EndUserNames []string `json:"endUserNames" xml:"endUserNames"`
}

EndUserNamesInDescribeDesktopsInGroup is a nested struct in ecd response

type EndUsers ¶

type EndUsers struct {
	EndUser []EndUser `json:"EndUser" xml:"EndUser"`
}

EndUsers is a nested struct in ecd response

type Event ¶

type Event struct {
	Status           string `json:"Status" xml:"Status"`
	BytesReceived    string `json:"BytesReceived" xml:"BytesReceived"`
	DesktopIp        string `json:"DesktopIp" xml:"DesktopIp"`
	EventTime        string `json:"EventTime" xml:"EventTime"`
	BytesSend        string `json:"BytesSend" xml:"BytesSend"`
	OfficeSiteId     string `json:"OfficeSiteId" xml:"OfficeSiteId"`
	AliUid           string `json:"AliUid" xml:"AliUid"`
	DesktopId        string `json:"DesktopId" xml:"DesktopId"`
	RegionId         string `json:"RegionId" xml:"RegionId"`
	EventId          string `json:"EventId" xml:"EventId"`
	DirectoryType    string `json:"DirectoryType" xml:"DirectoryType"`
	EventType        string `json:"EventType" xml:"EventType"`
	EndUserId        string `json:"EndUserId" xml:"EndUserId"`
	ClientIp         string `json:"ClientIp" xml:"ClientIp"`
	ClientOS         string `json:"ClientOS" xml:"ClientOS"`
	OfficeSiteType   string `json:"OfficeSiteType" xml:"OfficeSiteType"`
	DirectoryId      string `json:"DirectoryId" xml:"DirectoryId"`
	ClientVersion    string `json:"ClientVersion" xml:"ClientVersion"`
	OfficeSiteName   string `json:"OfficeSiteName" xml:"OfficeSiteName"`
	DesktopName      string `json:"DesktopName" xml:"DesktopName"`
	DesktopGroupId   string `json:"DesktopGroupId" xml:"DesktopGroupId"`
	DesktopGroupName string `json:"DesktopGroupName" xml:"DesktopGroupName"`
}

Event is a nested struct in ecd response

type Events ¶

type Events struct {
	Event []Event `json:"Event" xml:"Event"`
}

Events is a nested struct in ecd response

type ExportClientEventsRequest ¶

type ExportClientEventsRequest struct {
	*requests.RpcRequest
	OfficeSiteId   string           `position:"Query" name:"OfficeSiteId"`
	StartTime      string           `position:"Query" name:"StartTime"`
	EndUserId      string           `position:"Query" name:"EndUserId"`
	DesktopId      string           `position:"Query" name:"DesktopId"`
	DesktopName    string           `position:"Query" name:"DesktopName"`
	EndTime        string           `position:"Query" name:"EndTime"`
	OfficeSiteName string           `position:"Query" name:"OfficeSiteName"`
	MaxResults     requests.Integer `position:"Query" name:"MaxResults"`
	EventType      string           `position:"Query" name:"EventType"`
}

ExportClientEventsRequest is the request struct for api ExportClientEvents

func CreateExportClientEventsRequest ¶

func CreateExportClientEventsRequest() (request *ExportClientEventsRequest)

CreateExportClientEventsRequest creates a request to invoke ExportClientEvents API

type ExportClientEventsResponse ¶

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

ExportClientEventsResponse is the response struct for api ExportClientEvents

func CreateExportClientEventsResponse ¶

func CreateExportClientEventsResponse() (response *ExportClientEventsResponse)

CreateExportClientEventsResponse creates a response to parse from ExportClientEvents response

type ExportDesktopGroupInfoRequest ¶

type ExportDesktopGroupInfoRequest struct {
	*requests.RpcRequest
	OfficeSiteId     string           `position:"Query" name:"OfficeSiteId"`
	DesktopGroupName string           `position:"Query" name:"DesktopGroupName"`
	DesktopGroupId   *[]string        `position:"Query" name:"DesktopGroupId"  type:"Repeated"`
	NextToken        string           `position:"Query" name:"NextToken"`
	DirectoryId      string           `position:"Query" name:"DirectoryId"`
	EndUserId        *[]string        `position:"Query" name:"EndUserId"  type:"Repeated"`
	ExpiredTime      string           `position:"Query" name:"ExpiredTime"`
	MaxResults       requests.Integer `position:"Query" name:"MaxResults"`
	LangType         string           `position:"Query" name:"LangType"`
	ChargeType       string           `position:"Query" name:"ChargeType"`
	PolicyGroupId    string           `position:"Query" name:"PolicyGroupId"`
}

ExportDesktopGroupInfoRequest is the request struct for api ExportDesktopGroupInfo

func CreateExportDesktopGroupInfoRequest ¶

func CreateExportDesktopGroupInfoRequest() (request *ExportDesktopGroupInfoRequest)

CreateExportDesktopGroupInfoRequest creates a request to invoke ExportDesktopGroupInfo API

type ExportDesktopGroupInfoResponse ¶

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

ExportDesktopGroupInfoResponse is the response struct for api ExportDesktopGroupInfo

func CreateExportDesktopGroupInfoResponse ¶

func CreateExportDesktopGroupInfoResponse() (response *ExportDesktopGroupInfoResponse)

CreateExportDesktopGroupInfoResponse creates a response to parse from ExportDesktopGroupInfo response

type ExportDesktopListInfoRequest ¶

type ExportDesktopListInfoRequest struct {
	*requests.RpcRequest
	OfficeSiteId  string           `position:"Query" name:"OfficeSiteId"`
	DesktopStatus string           `position:"Query" name:"DesktopStatus"`
	NextToken     string           `position:"Query" name:"NextToken"`
	DirectoryId   string           `position:"Query" name:"DirectoryId"`
	EndUserId     *[]string        `position:"Query" name:"EndUserId"  type:"Repeated"`
	DesktopId     *[]string        `position:"Query" name:"DesktopId"  type:"Repeated"`
	DesktopName   string           `position:"Query" name:"DesktopName"`
	GroupId       string           `position:"Query" name:"GroupId"`
	ExpiredTime   string           `position:"Query" name:"ExpiredTime"`
	MaxResults    requests.Integer `position:"Query" name:"MaxResults"`
	LangType      string           `position:"Query" name:"LangType"`
	ChargeType    string           `position:"Query" name:"ChargeType"`
	PolicyGroupId string           `position:"Query" name:"PolicyGroupId"`
	UserName      string           `position:"Query" name:"UserName"`
}

ExportDesktopListInfoRequest is the request struct for api ExportDesktopListInfo

func CreateExportDesktopListInfoRequest ¶

func CreateExportDesktopListInfoRequest() (request *ExportDesktopListInfoRequest)

CreateExportDesktopListInfoRequest creates a request to invoke ExportDesktopListInfo API

type ExportDesktopListInfoResponse ¶

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

ExportDesktopListInfoResponse is the response struct for api ExportDesktopListInfo

func CreateExportDesktopListInfoResponse ¶

func CreateExportDesktopListInfoResponse() (response *ExportDesktopListInfoResponse)

CreateExportDesktopListInfoResponse creates a response to parse from ExportDesktopListInfo response

type ExtendContentJson ¶

type ExtendContentJson struct {
	RpmEntityList []RpmEntity `json:"RpmEntityList" xml:"RpmEntityList"`
}

ExtendContentJson is a nested struct in ecd response

type ExternalInfo ¶

type ExternalInfo struct {
	ExternalName string `json:"ExternalName" xml:"ExternalName"`
	JobNumber    string `json:"JobNumber" xml:"JobNumber"`
}

ExternalInfo is a nested struct in ecd response

type FileSystem ¶

type FileSystem struct {
	Capacity          int64  `json:"Capacity" xml:"Capacity"`
	MountTargetStatus string `json:"MountTargetStatus" xml:"MountTargetStatus"`
	CreateTime        string `json:"CreateTime" xml:"CreateTime"`
	OfficeSiteId      string `json:"OfficeSiteId" xml:"OfficeSiteId"`
	SupportAcl        bool   `json:"SupportAcl" xml:"SupportAcl"`
	StorageType       string `json:"StorageType" xml:"StorageType"`
	OfficeSiteName    string `json:"OfficeSiteName" xml:"OfficeSiteName"`
	RegionId          string `json:"RegionId" xml:"RegionId"`
	FileSystemId      string `json:"FileSystemId" xml:"FileSystemId"`
	FileSystemType    string `json:"FileSystemType" xml:"FileSystemType"`
	FileSystemName    string `json:"FileSystemName" xml:"FileSystemName"`
	MeteredSize       int64  `json:"MeteredSize" xml:"MeteredSize"`
	MountTargetDomain string `json:"MountTargetDomain" xml:"MountTargetDomain"`
	Description       string `json:"Description" xml:"Description"`
	ZoneId            string `json:"ZoneId" xml:"ZoneId"`
	FileSystemStatus  string `json:"FileSystemStatus" xml:"FileSystemStatus"`
	EncryptionEnabled bool   `json:"EncryptionEnabled" xml:"EncryptionEnabled"`
}

FileSystem is a nested struct in ecd response

type FileSystemIdsInDescribeDirectories ¶

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

FileSystemIdsInDescribeDirectories is a nested struct in ecd response

type FileSystemIdsInDescribeOfficeSites ¶

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

FileSystemIdsInDescribeOfficeSites is a nested struct in ecd response

type FileSystems ¶

type FileSystems struct {
	FileSystem []FileSystem `json:"FileSystem" xml:"FileSystem"`
}

FileSystems is a nested struct in ecd response

type FlowStatistic ¶

type FlowStatistic struct {
	DesktopName string `json:"DesktopName" xml:"DesktopName"`
	DesktopId   string `json:"DesktopId" xml:"DesktopId"`
	FlowRank    int    `json:"FlowRank" xml:"FlowRank"`
	FlowIn      string `json:"FlowIn" xml:"FlowIn"`
}

FlowStatistic is a nested struct in ecd response

type FotaPendingDesktop ¶

type FotaPendingDesktop struct {
	DesktopId         string `json:"DesktopId" xml:"DesktopId"`
	DesktopName       string `json:"DesktopName" xml:"DesktopName"`
	OfficeSiteId      string `json:"OfficeSiteId" xml:"OfficeSiteId"`
	FotaProject       string `json:"FotaProject" xml:"FotaProject"`
	CurrentAppVersion string `json:"CurrentAppVersion" xml:"CurrentAppVersion"`
}

FotaPendingDesktop is a nested struct in ecd response

type FotaPendingDesktops ¶

type FotaPendingDesktops struct {
	FotaPendingDesktop []FotaPendingDesktop `json:"FotaPendingDesktop" xml:"FotaPendingDesktop"`
}

FotaPendingDesktops is a nested struct in ecd response

type FotaTask ¶

type FotaTask struct {
	TaskUid             string `json:"TaskUid" xml:"TaskUid"`
	FotaProject         string `json:"FotaProject" xml:"FotaProject"`
	AppVersion          string `json:"AppVersion" xml:"AppVersion"`
	Status              string `json:"Status" xml:"Status"`
	PublishTime         string `json:"PublishTime" xml:"PublishTime"`
	PendingDesktopCount int    `json:"PendingDesktopCount" xml:"PendingDesktopCount"`
	ReleaseNote         string `json:"ReleaseNote" xml:"ReleaseNote"`
	Size                int    `json:"Size" xml:"Size"`
}

FotaTask is a nested struct in ecd response

type FotaTasks ¶

type FotaTasks struct {
	FotaTask []FotaTask `json:"FotaTask" xml:"FotaTask"`
}

FotaTasks is a nested struct in ecd response

type FotaUpdate ¶

type FotaUpdate struct {
	CurrentAppVersion string `json:"CurrentAppVersion" xml:"CurrentAppVersion"`
	NewAppVersion     string `json:"NewAppVersion" xml:"NewAppVersion"`
	ReleaseNote       string `json:"ReleaseNote" xml:"ReleaseNote"`
	Size              int64  `json:"Size" xml:"Size"`
}

FotaUpdate is a nested struct in ecd response

type FrontPatchItem ¶

type FrontPatchItem struct {
	DesktopId string      `json:"DesktopId" xml:"DesktopId"`
	PatchList []PatchItem `json:"PatchList" xml:"PatchList"`
}

FrontPatchItem is a nested struct in ecd response

type FrontPatchList ¶

type FrontPatchList struct {
	FrontPatchItem []FrontPatchItem `json:"FrontPatchItem" xml:"FrontPatchItem"`
}

FrontPatchList is a nested struct in ecd response

type GetConnectionTicketRequest ¶

type GetConnectionTicketRequest struct {
	*requests.RpcRequest
	ResourceOwnerId      requests.Integer `position:"Query" name:"ResourceOwnerId"`
	Uuid                 string           `position:"Query" name:"Uuid"`
	Password             string           `position:"Query" name:"Password"`
	EndUserId            string           `position:"Query" name:"EndUserId"`
	DesktopId            string           `position:"Query" name:"DesktopId"`
	TaskId               string           `position:"Query" name:"TaskId"`
	ResourceOwnerAccount string           `position:"Query" name:"ResourceOwnerAccount"`
	OwnerId              requests.Integer `position:"Query" name:"OwnerId"`
}

GetConnectionTicketRequest is the request struct for api GetConnectionTicket

func CreateGetConnectionTicketRequest ¶

func CreateGetConnectionTicketRequest() (request *GetConnectionTicketRequest)

CreateGetConnectionTicketRequest creates a request to invoke GetConnectionTicket API

type GetConnectionTicketResponse ¶

type GetConnectionTicketResponse struct {
	*responses.BaseResponse
	RequestId  string `json:"RequestId" xml:"RequestId"`
	TaskStatus string `json:"TaskStatus" xml:"TaskStatus"`
	Ticket     string `json:"Ticket" xml:"Ticket"`
	TaskId     string `json:"TaskId" xml:"TaskId"`
}

GetConnectionTicketResponse is the response struct for api GetConnectionTicket

func CreateGetConnectionTicketResponse ¶

func CreateGetConnectionTicketResponse() (response *GetConnectionTicketResponse)

CreateGetConnectionTicketResponse creates a response to parse from GetConnectionTicket response

type GetDesktopGroupDetailRequest ¶

type GetDesktopGroupDetailRequest struct {
	*requests.RpcRequest
	DesktopGroupId string `position:"Query" name:"DesktopGroupId"`
}

GetDesktopGroupDetailRequest is the request struct for api GetDesktopGroupDetail

func CreateGetDesktopGroupDetailRequest ¶

func CreateGetDesktopGroupDetailRequest() (request *GetDesktopGroupDetailRequest)

CreateGetDesktopGroupDetailRequest creates a request to invoke GetDesktopGroupDetail API

type GetDesktopGroupDetailResponse ¶

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

GetDesktopGroupDetailResponse is the response struct for api GetDesktopGroupDetail

func CreateGetDesktopGroupDetailResponse ¶

func CreateGetDesktopGroupDetailResponse() (response *GetDesktopGroupDetailResponse)

CreateGetDesktopGroupDetailResponse creates a response to parse from GetDesktopGroupDetail response

type GetDirectorySsoStatusRequest ¶

type GetDirectorySsoStatusRequest struct {
	*requests.RpcRequest
	DirectoryId string `position:"Query" name:"DirectoryId"`
}

GetDirectorySsoStatusRequest is the request struct for api GetDirectorySsoStatus

func CreateGetDirectorySsoStatusRequest ¶

func CreateGetDirectorySsoStatusRequest() (request *GetDirectorySsoStatusRequest)

CreateGetDirectorySsoStatusRequest creates a request to invoke GetDirectorySsoStatus API

type GetDirectorySsoStatusResponse ¶

type GetDirectorySsoStatusResponse struct {
	*responses.BaseResponse
	SsoStatus bool   `json:"SsoStatus" xml:"SsoStatus"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

GetDirectorySsoStatusResponse is the response struct for api GetDirectorySsoStatus

func CreateGetDirectorySsoStatusResponse ¶

func CreateGetDirectorySsoStatusResponse() (response *GetDirectorySsoStatusResponse)

CreateGetDirectorySsoStatusResponse creates a response to parse from GetDirectorySsoStatus response

type GetOfficeSiteSsoStatusRequest ¶

type GetOfficeSiteSsoStatusRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
}

GetOfficeSiteSsoStatusRequest is the request struct for api GetOfficeSiteSsoStatus

func CreateGetOfficeSiteSsoStatusRequest ¶

func CreateGetOfficeSiteSsoStatusRequest() (request *GetOfficeSiteSsoStatusRequest)

CreateGetOfficeSiteSsoStatusRequest creates a request to invoke GetOfficeSiteSsoStatus API

type GetOfficeSiteSsoStatusResponse ¶

type GetOfficeSiteSsoStatusResponse struct {
	*responses.BaseResponse
	SsoStatus bool   `json:"SsoStatus" xml:"SsoStatus"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

GetOfficeSiteSsoStatusResponse is the response struct for api GetOfficeSiteSsoStatus

func CreateGetOfficeSiteSsoStatusResponse ¶

func CreateGetOfficeSiteSsoStatusResponse() (response *GetOfficeSiteSsoStatusResponse)

CreateGetOfficeSiteSsoStatusResponse creates a response to parse from GetOfficeSiteSsoStatus response

type GetSpMetadataRequest ¶

type GetSpMetadataRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
	DirectoryId  string `position:"Query" name:"DirectoryId"`
}

GetSpMetadataRequest is the request struct for api GetSpMetadata

func CreateGetSpMetadataRequest ¶

func CreateGetSpMetadataRequest() (request *GetSpMetadataRequest)

CreateGetSpMetadataRequest creates a request to invoke GetSpMetadata API

type GetSpMetadataResponse ¶

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

GetSpMetadataResponse is the response struct for api GetSpMetadata

func CreateGetSpMetadataResponse ¶

func CreateGetSpMetadataResponse() (response *GetSpMetadataResponse)

CreateGetSpMetadataResponse creates a response to parse from GetSpMetadata response

type GroupedVulItem ¶

type GroupedVulItem struct {
	Type         string `json:"Type" xml:"Type"`
	NntfCount    int    `json:"NntfCount" xml:"NntfCount"`
	HandledCount int    `json:"HandledCount" xml:"HandledCount"`
	GmtLast      string `json:"GmtLast" xml:"GmtLast"`
	Tags         string `json:"Tags" xml:"Tags"`
	LaterCount   int    `json:"LaterCount" xml:"LaterCount"`
	AliasName    string `json:"AliasName" xml:"AliasName"`
	Name         string `json:"Name" xml:"Name"`
	AsapCount    int    `json:"AsapCount" xml:"AsapCount"`
}

GroupedVulItem is a nested struct in ecd response

type GroupedVulItems ¶

type GroupedVulItems struct {
	GroupedVulItem []GroupedVulItem `json:"GroupedVulItem" xml:"GroupedVulItem"`
}

GroupedVulItems is a nested struct in ecd response

type HandleSecurityEventsRequest ¶

type HandleSecurityEventsRequest struct {
	*requests.RpcRequest
	SecurityEvent   *[]HandleSecurityEventsSecurityEvent `position:"Query" name:"SecurityEvent"  type:"Repeated"`
	OperationCode   string                               `position:"Query" name:"OperationCode"`
	OperationParams string                               `position:"Query" name:"OperationParams"`
}

HandleSecurityEventsRequest is the request struct for api HandleSecurityEvents

func CreateHandleSecurityEventsRequest ¶

func CreateHandleSecurityEventsRequest() (request *HandleSecurityEventsRequest)

CreateHandleSecurityEventsRequest creates a request to invoke HandleSecurityEvents API

type HandleSecurityEventsResponse ¶

type HandleSecurityEventsResponse struct {
	*responses.BaseResponse
	TaskId    int64  `json:"TaskId" xml:"TaskId"`
	RequestId string `json:"RequestId" xml:"RequestId"`
}

HandleSecurityEventsResponse is the response struct for api HandleSecurityEvents

func CreateHandleSecurityEventsResponse ¶

func CreateHandleSecurityEventsResponse() (response *HandleSecurityEventsResponse)

CreateHandleSecurityEventsResponse creates a response to parse from HandleSecurityEvents response

type HandleSecurityEventsSecurityEvent ¶

type HandleSecurityEventsSecurityEvent struct {
	DesktopId       string `name:"DesktopId"`
	SecurityEventId string `name:"SecurityEventId"`
}

HandleSecurityEventsSecurityEvent is a repeated param struct in HandleSecurityEventsRequest

type Image ¶

type Image struct {
	CreationTime            string   `json:"CreationTime" xml:"CreationTime"`
	Status                  string   `json:"Status" xml:"Status"`
	Progress                string   `json:"Progress" xml:"Progress"`
	DataDiskSize            int      `json:"DataDiskSize" xml:"DataDiskSize"`
	ImageType               string   `json:"ImageType" xml:"ImageType"`
	Description             string   `json:"Description" xml:"Description"`
	Size                    int      `json:"Size" xml:"Size"`
	OsType                  string   `json:"OsType" xml:"OsType"`
	ProtocolType            string   `json:"ProtocolType" xml:"ProtocolType"`
	Name                    string   `json:"Name" xml:"Name"`
	ImageId                 string   `json:"ImageId" xml:"ImageId"`
	GpuCategory             bool     `json:"GpuCategory" xml:"GpuCategory"`
	GpuDriverVersion        string   `json:"GpuDriverVersion" xml:"GpuDriverVersion"`
	AppVersion              string   `json:"AppVersion" xml:"AppVersion"`
	VolumeEncryptionEnabled bool     `json:"VolumeEncryptionEnabled" xml:"VolumeEncryptionEnabled"`
	VolumeEncryptionKey     string   `json:"VolumeEncryptionKey" xml:"VolumeEncryptionKey"`
	SharedCount             int      `json:"SharedCount" xml:"SharedCount"`
	SessionType             string   `json:"SessionType" xml:"SessionType"`
	SupportedLanguages      []string `json:"SupportedLanguages" xml:"SupportedLanguages"`
}

Image is a nested struct in ecd response

type ImageModifiedRecord ¶

type ImageModifiedRecord struct {
	Status       int    `json:"Status" xml:"Status"`
	UpdateTime   string `json:"UpdateTime" xml:"UpdateTime"`
	NewImageName string `json:"NewImageName" xml:"NewImageName"`
	ImageName    string `json:"ImageName" xml:"ImageName"`
	NewImageId   string `json:"NewImageId" xml:"NewImageId"`
	ImageId      string `json:"ImageId" xml:"ImageId"`
}

ImageModifiedRecord is a nested struct in ecd response

type ImageModifiedRecords ¶

type ImageModifiedRecords struct {
	ImageModifiedRecord []ImageModifiedRecord `json:"ImageModifiedRecord" xml:"ImageModifiedRecord"`
}

ImageModifiedRecords is a nested struct in ecd response

type Images ¶

type Images struct {
	Image []Image `json:"Image" xml:"Image"`
}

Images is a nested struct in ecd response

type Invocation ¶

type Invocation struct {
	InvokeId         string          `json:"InvokeId" xml:"InvokeId"`
	CommandContent   string          `json:"CommandContent" xml:"CommandContent"`
	CommandType      string          `json:"CommandType" xml:"CommandType"`
	InvocationStatus string          `json:"InvocationStatus" xml:"InvocationStatus"`
	CreationTime     string          `json:"CreationTime" xml:"CreationTime"`
	EndUserId        string          `json:"EndUserId" xml:"EndUserId"`
	InvokeDesktops   []InvokeDesktop `json:"InvokeDesktops" xml:"InvokeDesktops"`
}

Invocation is a nested struct in ecd response

type Invocations ¶

type Invocations struct {
	Invocation []Invocation `json:"Invocation" xml:"Invocation"`
}

Invocations is a nested struct in ecd response

type InvokeDesktop ¶

type InvokeDesktop struct {
	InvocationStatus string `json:"InvocationStatus" xml:"InvocationStatus"`
	Output           string `json:"Output" xml:"Output"`
	CreationTime     string `json:"CreationTime" xml:"CreationTime"`
	UpdateTime       string `json:"UpdateTime" xml:"UpdateTime"`
	Repeats          int    `json:"Repeats" xml:"Repeats"`
	DesktopId        string `json:"DesktopId" xml:"DesktopId"`
	Dropped          int    `json:"Dropped" xml:"Dropped"`
	StartTime        string `json:"StartTime" xml:"StartTime"`
	StopTime         string `json:"StopTime" xml:"StopTime"`
	FinishTime       string `json:"FinishTime" xml:"FinishTime"`
	ExitCode         int64  `json:"ExitCode" xml:"ExitCode"`
	ErrorCode        string `json:"ErrorCode" xml:"ErrorCode"`
	ErrorInfo        string `json:"ErrorInfo" xml:"ErrorInfo"`
}

InvokeDesktop is a nested struct in ecd response

type InvokeDesktops ¶

type InvokeDesktops struct {
	InvokeDesktop []InvokeDesktop `json:"InvokeDesktop" xml:"InvokeDesktop"`
}

InvokeDesktops is a nested struct in ecd response

type Key ¶

type Key struct {
	KeyId string `json:"KeyId" xml:"KeyId"`
	Arn   string `json:"Arn" xml:"Arn"`
	Alias string `json:"Alias" xml:"Alias"`
	Type  string `json:"Type" xml:"Type"`
}

Key is a nested struct in ecd response

type Keys ¶

type Keys struct {
	Key []Key `json:"Key" xml:"Key"`
}

Keys is a nested struct in ecd response

type ListDirectoryUsersRequest ¶

type ListDirectoryUsersRequest struct {
	*requests.RpcRequest
	OUPath      string           `position:"Query" name:"OUPath"`
	Filter      string           `position:"Query" name:"Filter"`
	NextToken   string           `position:"Query" name:"NextToken"`
	MaxResults  requests.Integer `position:"Query" name:"MaxResults"`
	DirectoryId string           `position:"Query" name:"DirectoryId"`
}

ListDirectoryUsersRequest is the request struct for api ListDirectoryUsers

func CreateListDirectoryUsersRequest ¶

func CreateListDirectoryUsersRequest() (request *ListDirectoryUsersRequest)

CreateListDirectoryUsersRequest creates a request to invoke ListDirectoryUsers API

type ListDirectoryUsersResponse ¶

type ListDirectoryUsersResponse struct {
	*responses.BaseResponse
	NextToken string `json:"NextToken" xml:"NextToken"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Users     []User `json:"Users" xml:"Users"`
}

ListDirectoryUsersResponse is the response struct for api ListDirectoryUsers

func CreateListDirectoryUsersResponse ¶

func CreateListDirectoryUsersResponse() (response *ListDirectoryUsersResponse)

CreateListDirectoryUsersResponse creates a response to parse from ListDirectoryUsers response

type ListOfficeSiteOverviewRequest ¶

type ListOfficeSiteOverviewRequest struct {
	*requests.RpcRequest
	OfficeSiteId *[]string        `position:"Query" name:"OfficeSiteId"  type:"Repeated"`
	QueryRange   requests.Integer `position:"Query" name:"QueryRange"`
	ForceRefresh requests.Boolean `position:"Query" name:"ForceRefresh"`
	NextToken    string           `position:"Query" name:"NextToken"`
	MaxResults   requests.Integer `position:"Query" name:"MaxResults"`
}

ListOfficeSiteOverviewRequest is the request struct for api ListOfficeSiteOverview

func CreateListOfficeSiteOverviewRequest ¶

func CreateListOfficeSiteOverviewRequest() (request *ListOfficeSiteOverviewRequest)

CreateListOfficeSiteOverviewRequest creates a request to invoke ListOfficeSiteOverview API

type ListOfficeSiteOverviewResponse ¶

type ListOfficeSiteOverviewResponse struct {
	*responses.BaseResponse
	NextToken                 string                     `json:"NextToken" xml:"NextToken"`
	RequestId                 string                     `json:"RequestId" xml:"RequestId"`
	OfficeSiteOverviewResults []OfficeSiteOverviewResult `json:"OfficeSiteOverviewResults" xml:"OfficeSiteOverviewResults"`
}

ListOfficeSiteOverviewResponse is the response struct for api ListOfficeSiteOverview

func CreateListOfficeSiteOverviewResponse ¶

func CreateListOfficeSiteOverviewResponse() (response *ListOfficeSiteOverviewResponse)

CreateListOfficeSiteOverviewResponse creates a response to parse from ListOfficeSiteOverview response

type ListOfficeSiteUsersRequest ¶

type ListOfficeSiteUsersRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	OUPath       string           `position:"Query" name:"OUPath"`
	Filter       string           `position:"Query" name:"Filter"`
	NextToken    string           `position:"Query" name:"NextToken"`
	MaxResults   requests.Integer `position:"Query" name:"MaxResults"`
}

ListOfficeSiteUsersRequest is the request struct for api ListOfficeSiteUsers

func CreateListOfficeSiteUsersRequest ¶

func CreateListOfficeSiteUsersRequest() (request *ListOfficeSiteUsersRequest)

CreateListOfficeSiteUsersRequest creates a request to invoke ListOfficeSiteUsers API

type ListOfficeSiteUsersResponse ¶

type ListOfficeSiteUsersResponse struct {
	*responses.BaseResponse
	NextToken string `json:"NextToken" xml:"NextToken"`
	RequestId string `json:"RequestId" xml:"RequestId"`
	Users     []User `json:"Users" xml:"Users"`
}

ListOfficeSiteUsersResponse is the response struct for api ListOfficeSiteUsers

func CreateListOfficeSiteUsersResponse ¶

func CreateListOfficeSiteUsersResponse() (response *ListOfficeSiteUsersResponse)

CreateListOfficeSiteUsersResponse creates a response to parse from ListOfficeSiteUsers response

type ListTagResourcesRequest ¶

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

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
	NextToken    string        `json:"NextToken" xml:"NextToken"`
	RequestId    string        `json:"RequestId" xml:"RequestId"`
	TagResources []TagResource `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 {
	Value string `name:"Value"`
	Key   string `name:"Key"`
}

ListTagResourcesTag is a repeated param struct in ListTagResourcesRequest

type ListUserAdOrganizationUnitsRequest ¶

type ListUserAdOrganizationUnitsRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
}

ListUserAdOrganizationUnitsRequest is the request struct for api ListUserAdOrganizationUnits

func CreateListUserAdOrganizationUnitsRequest ¶

func CreateListUserAdOrganizationUnitsRequest() (request *ListUserAdOrganizationUnitsRequest)

CreateListUserAdOrganizationUnitsRequest creates a request to invoke ListUserAdOrganizationUnits API

type ListUserAdOrganizationUnitsResponse ¶

type ListUserAdOrganizationUnitsResponse struct {
	*responses.BaseResponse
	RequestId string   `json:"RequestId" xml:"RequestId"`
	OUNames   []OuName `json:"OUNames" xml:"OUNames"`
}

ListUserAdOrganizationUnitsResponse is the response struct for api ListUserAdOrganizationUnits

func CreateListUserAdOrganizationUnitsResponse ¶

func CreateListUserAdOrganizationUnitsResponse() (response *ListUserAdOrganizationUnitsResponse)

CreateListUserAdOrganizationUnitsResponse creates a response to parse from ListUserAdOrganizationUnits response

type LockVirtualMFADeviceRequest ¶

type LockVirtualMFADeviceRequest struct {
	*requests.RpcRequest
	SerialNumber string `position:"Query" name:"SerialNumber"`
}

LockVirtualMFADeviceRequest is the request struct for api LockVirtualMFADevice

func CreateLockVirtualMFADeviceRequest ¶

func CreateLockVirtualMFADeviceRequest() (request *LockVirtualMFADeviceRequest)

CreateLockVirtualMFADeviceRequest creates a request to invoke LockVirtualMFADevice API

type LockVirtualMFADeviceResponse ¶

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

LockVirtualMFADeviceResponse is the response struct for api LockVirtualMFADevice

func CreateLockVirtualMFADeviceResponse ¶

func CreateLockVirtualMFADeviceResponse() (response *LockVirtualMFADeviceResponse)

CreateLockVirtualMFADeviceResponse creates a response to parse from LockVirtualMFADevice response

type Log ¶

type Log struct {
	Message   string `json:"Message" xml:"Message"`
	TimeStamp string `json:"TimeStamp" xml:"TimeStamp"`
	Level     string `json:"Level" xml:"Level"`
	Step      string `json:"Step" xml:"Step"`
}

Log is a nested struct in ecd response

type LogsInDescribeDirectories ¶

type LogsInDescribeDirectories struct {
	Log []Log `json:"Log" xml:"Log"`
}

LogsInDescribeDirectories is a nested struct in ecd response

type LogsInDescribeOfficeSites ¶

type LogsInDescribeOfficeSites struct {
	Log []Log `json:"Log" xml:"Log"`
}

LogsInDescribeOfficeSites is a nested struct in ecd response

type ModifyADConnectorDirectoryRequest ¶

type ModifyADConnectorDirectoryRequest struct {
	*requests.RpcRequest
	SubDomainDnsAddress *[]string        `position:"Query" name:"SubDomainDnsAddress"  type:"Repeated"`
	SubDomainName       string           `position:"Query" name:"SubDomainName"`
	DomainPassword      string           `position:"Query" name:"DomainPassword"`
	DirectoryId         string           `position:"Query" name:"DirectoryId"`
	AdHostname          string           `position:"Query" name:"AdHostname"`
	DomainName          string           `position:"Query" name:"DomainName"`
	DirectoryName       string           `position:"Query" name:"DirectoryName"`
	MfaEnabled          requests.Boolean `position:"Query" name:"MfaEnabled"`
	DomainUserName      string           `position:"Query" name:"DomainUserName"`
	DnsAddress          *[]string        `position:"Query" name:"DnsAddress"  type:"Repeated"`
	OUName              string           `position:"Query" name:"OUName"`
}

ModifyADConnectorDirectoryRequest is the request struct for api ModifyADConnectorDirectory

func CreateModifyADConnectorDirectoryRequest ¶

func CreateModifyADConnectorDirectoryRequest() (request *ModifyADConnectorDirectoryRequest)

CreateModifyADConnectorDirectoryRequest creates a request to invoke ModifyADConnectorDirectory API

type ModifyADConnectorDirectoryResponse ¶

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

ModifyADConnectorDirectoryResponse is the response struct for api ModifyADConnectorDirectory

func CreateModifyADConnectorDirectoryResponse ¶

func CreateModifyADConnectorDirectoryResponse() (response *ModifyADConnectorDirectoryResponse)

CreateModifyADConnectorDirectoryResponse creates a response to parse from ModifyADConnectorDirectory response

type ModifyADConnectorOfficeSiteRequest ¶

type ModifyADConnectorOfficeSiteRequest struct {
	*requests.RpcRequest
	OfficeSiteId        string           `position:"Query" name:"OfficeSiteId"`
	SubDomainDnsAddress *[]string        `position:"Query" name:"SubDomainDnsAddress"  type:"Repeated"`
	SubDomainName       string           `position:"Query" name:"SubDomainName"`
	DomainPassword      string           `position:"Query" name:"DomainPassword"`
	AdHostname          string           `position:"Query" name:"AdHostname"`
	DomainName          string           `position:"Query" name:"DomainName"`
	OfficeSiteName      string           `position:"Query" name:"OfficeSiteName"`
	MfaEnabled          requests.Boolean `position:"Query" name:"MfaEnabled"`
	DomainUserName      string           `position:"Query" name:"DomainUserName"`
	DnsAddress          *[]string        `position:"Query" name:"DnsAddress"  type:"Repeated"`
	OUName              string           `position:"Query" name:"OUName"`
}

ModifyADConnectorOfficeSiteRequest is the request struct for api ModifyADConnectorOfficeSite

func CreateModifyADConnectorOfficeSiteRequest ¶

func CreateModifyADConnectorOfficeSiteRequest() (request *ModifyADConnectorOfficeSiteRequest)

CreateModifyADConnectorOfficeSiteRequest creates a request to invoke ModifyADConnectorOfficeSite API

type ModifyADConnectorOfficeSiteResponse ¶

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

ModifyADConnectorOfficeSiteResponse is the response struct for api ModifyADConnectorOfficeSite

func CreateModifyADConnectorOfficeSiteResponse ¶

func CreateModifyADConnectorOfficeSiteResponse() (response *ModifyADConnectorOfficeSiteResponse)

CreateModifyADConnectorOfficeSiteResponse creates a response to parse from ModifyADConnectorOfficeSite response

type ModifyBundleRequest ¶

type ModifyBundleRequest struct {
	*requests.RpcRequest
	ImageId     string `position:"Query" name:"ImageId"`
	BundleId    string `position:"Query" name:"BundleId"`
	Description string `position:"Query" name:"Description"`
	Language    string `position:"Query" name:"Language"`
	BundleName  string `position:"Query" name:"BundleName"`
}

ModifyBundleRequest is the request struct for api ModifyBundle

func CreateModifyBundleRequest ¶

func CreateModifyBundleRequest() (request *ModifyBundleRequest)

CreateModifyBundleRequest creates a request to invoke ModifyBundle API

type ModifyBundleResponse ¶

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

ModifyBundleResponse is the response struct for api ModifyBundle

func CreateModifyBundleResponse ¶

func CreateModifyBundleResponse() (response *ModifyBundleResponse)

CreateModifyBundleResponse creates a response to parse from ModifyBundle response

type ModifyDesktopChargeTypeRequest ¶

type ModifyDesktopChargeTypeRequest struct {
	*requests.RpcRequest
	Period      requests.Integer `position:"Query" name:"Period"`
	AutoPay     requests.Boolean `position:"Query" name:"AutoPay"`
	PromotionId string           `position:"Query" name:"PromotionId"`
	PeriodUnit  string           `position:"Query" name:"PeriodUnit"`
	ChargeType  string           `position:"Query" name:"ChargeType"`
	DesktopId   *[]string        `position:"Query" name:"DesktopId"  type:"Repeated"`
}

ModifyDesktopChargeTypeRequest is the request struct for api ModifyDesktopChargeType

func CreateModifyDesktopChargeTypeRequest ¶

func CreateModifyDesktopChargeTypeRequest() (request *ModifyDesktopChargeTypeRequest)

CreateModifyDesktopChargeTypeRequest creates a request to invoke ModifyDesktopChargeType API

type ModifyDesktopChargeTypeResponse ¶

type ModifyDesktopChargeTypeResponse struct {
	*responses.BaseResponse
	OrderId   string   `json:"OrderId" xml:"OrderId"`
	RequestId string   `json:"RequestId" xml:"RequestId"`
	DesktopId []string `json:"DesktopId" xml:"DesktopId"`
}

ModifyDesktopChargeTypeResponse is the response struct for api ModifyDesktopChargeType

func CreateModifyDesktopChargeTypeResponse ¶

func CreateModifyDesktopChargeTypeResponse() (response *ModifyDesktopChargeTypeResponse)

CreateModifyDesktopChargeTypeResponse creates a response to parse from ModifyDesktopChargeType response

type ModifyDesktopGroupRequest ¶

type ModifyDesktopGroupRequest struct {
	*requests.RpcRequest
	Classify         string           `position:"Query" name:"Classify"`
	ImageId          string           `position:"Query" name:"ImageId"`
	ScaleStrategyId  string           `position:"Query" name:"ScaleStrategyId"`
	BindAmount       requests.Integer `position:"Query" name:"BindAmount"`
	LoadPolicy       requests.Integer `position:"Query" name:"LoadPolicy"`
	DesktopGroupName string           `position:"Query" name:"DesktopGroupName"`
	AllowBufferCount requests.Integer `position:"Query" name:"AllowBufferCount"`
	DesktopGroupId   string           `position:"Query" name:"DesktopGroupId"`
	MinDesktopsCount requests.Integer `position:"Query" name:"MinDesktopsCount"`
	MaxDesktopsCount requests.Integer `position:"Query" name:"MaxDesktopsCount"`
	AllowAutoSetup   requests.Integer `position:"Query" name:"AllowAutoSetup"`
	Comments         string           `position:"Query" name:"Comments"`
	ResetType        requests.Integer `position:"Query" name:"ResetType"`
	OwnBundleId      string           `position:"Query" name:"OwnBundleId"`
	KeepDuration     requests.Integer `position:"Query" name:"KeepDuration"`
	PolicyGroupId    string           `position:"Query" name:"PolicyGroupId"`
}

ModifyDesktopGroupRequest is the request struct for api ModifyDesktopGroup

func CreateModifyDesktopGroupRequest ¶

func CreateModifyDesktopGroupRequest() (request *ModifyDesktopGroupRequest)

CreateModifyDesktopGroupRequest creates a request to invoke ModifyDesktopGroup API

type ModifyDesktopGroupResponse ¶

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

ModifyDesktopGroupResponse is the response struct for api ModifyDesktopGroup

func CreateModifyDesktopGroupResponse ¶

func CreateModifyDesktopGroupResponse() (response *ModifyDesktopGroupResponse)

CreateModifyDesktopGroupResponse creates a response to parse from ModifyDesktopGroup response

type ModifyDesktopHostNameRequest ¶

type ModifyDesktopHostNameRequest struct {
	*requests.RpcRequest
	DesktopId   string `position:"Query" name:"DesktopId"`
	NewHostName string `position:"Query" name:"NewHostName"`
}

ModifyDesktopHostNameRequest is the request struct for api ModifyDesktopHostName

func CreateModifyDesktopHostNameRequest ¶

func CreateModifyDesktopHostNameRequest() (request *ModifyDesktopHostNameRequest)

CreateModifyDesktopHostNameRequest creates a request to invoke ModifyDesktopHostName API

type ModifyDesktopHostNameResponse ¶

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

ModifyDesktopHostNameResponse is the response struct for api ModifyDesktopHostName

func CreateModifyDesktopHostNameResponse ¶

func CreateModifyDesktopHostNameResponse() (response *ModifyDesktopHostNameResponse)

CreateModifyDesktopHostNameResponse creates a response to parse from ModifyDesktopHostName response

type ModifyDesktopNameRequest ¶

type ModifyDesktopNameRequest struct {
	*requests.RpcRequest
	NewDesktopName string `position:"Query" name:"NewDesktopName"`
	DesktopId      string `position:"Query" name:"DesktopId"`
}

ModifyDesktopNameRequest is the request struct for api ModifyDesktopName

func CreateModifyDesktopNameRequest ¶

func CreateModifyDesktopNameRequest() (request *ModifyDesktopNameRequest)

CreateModifyDesktopNameRequest creates a request to invoke ModifyDesktopName API

type ModifyDesktopNameResponse ¶

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

ModifyDesktopNameResponse is the response struct for api ModifyDesktopName

func CreateModifyDesktopNameResponse ¶

func CreateModifyDesktopNameResponse() (response *ModifyDesktopNameResponse)

CreateModifyDesktopNameResponse creates a response to parse from ModifyDesktopName response

type ModifyDesktopSpecRequest ¶

type ModifyDesktopSpecRequest struct {
	*requests.RpcRequest
	AutoPay                  requests.Boolean `position:"Query" name:"AutoPay"`
	UserDiskPerformanceLevel string           `position:"Query" name:"UserDiskPerformanceLevel"`
	PromotionId              string           `position:"Query" name:"PromotionId"`
	UserDiskSizeGib          requests.Integer `position:"Query" name:"UserDiskSizeGib"`
	DesktopId                string           `position:"Query" name:"DesktopId"`
	DesktopType              string           `position:"Query" name:"DesktopType"`
	RootDiskSizeGib          requests.Integer `position:"Query" name:"RootDiskSizeGib"`
}

ModifyDesktopSpecRequest is the request struct for api ModifyDesktopSpec

func CreateModifyDesktopSpecRequest ¶

func CreateModifyDesktopSpecRequest() (request *ModifyDesktopSpecRequest)

CreateModifyDesktopSpecRequest creates a request to invoke ModifyDesktopSpec API

type ModifyDesktopSpecResponse ¶

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

ModifyDesktopSpecResponse is the response struct for api ModifyDesktopSpec

func CreateModifyDesktopSpecResponse ¶

func CreateModifyDesktopSpecResponse() (response *ModifyDesktopSpecResponse)

CreateModifyDesktopSpecResponse creates a response to parse from ModifyDesktopSpec response

type ModifyDesktopsPolicyGroupRequest ¶

type ModifyDesktopsPolicyGroupRequest struct {
	*requests.RpcRequest
	DesktopId     *[]string `position:"Query" name:"DesktopId"  type:"Repeated"`
	PolicyGroupId string    `position:"Query" name:"PolicyGroupId"`
}

ModifyDesktopsPolicyGroupRequest is the request struct for api ModifyDesktopsPolicyGroup

func CreateModifyDesktopsPolicyGroupRequest ¶

func CreateModifyDesktopsPolicyGroupRequest() (request *ModifyDesktopsPolicyGroupRequest)

CreateModifyDesktopsPolicyGroupRequest creates a request to invoke ModifyDesktopsPolicyGroup API

type ModifyDesktopsPolicyGroupResponse ¶

type ModifyDesktopsPolicyGroupResponse struct {
	*responses.BaseResponse
	RequestId     string         `json:"RequestId" xml:"RequestId"`
	ModifyResults []ModifyResult `json:"ModifyResults" xml:"ModifyResults"`
}

ModifyDesktopsPolicyGroupResponse is the response struct for api ModifyDesktopsPolicyGroup

func CreateModifyDesktopsPolicyGroupResponse ¶

func CreateModifyDesktopsPolicyGroupResponse() (response *ModifyDesktopsPolicyGroupResponse)

CreateModifyDesktopsPolicyGroupResponse creates a response to parse from ModifyDesktopsPolicyGroup response

type ModifyDiskSpecRequest ¶

type ModifyDiskSpecRequest struct {
	*requests.RpcRequest
	RootDiskPerformanceLevel string           `position:"Query" name:"RootDiskPerformanceLevel"`
	AutoPay                  requests.Boolean `position:"Query" name:"AutoPay"`
	UserDiskPerformanceLevel string           `position:"Query" name:"UserDiskPerformanceLevel"`
	PromotionId              string           `position:"Query" name:"PromotionId"`
	DesktopId                string           `position:"Query" name:"DesktopId"`
}

ModifyDiskSpecRequest is the request struct for api ModifyDiskSpec

func CreateModifyDiskSpecRequest ¶

func CreateModifyDiskSpecRequest() (request *ModifyDiskSpecRequest)

CreateModifyDiskSpecRequest creates a request to invoke ModifyDiskSpec API

type ModifyDiskSpecResponse ¶

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

ModifyDiskSpecResponse is the response struct for api ModifyDiskSpec

func CreateModifyDiskSpecResponse ¶

func CreateModifyDiskSpecResponse() (response *ModifyDiskSpecResponse)

CreateModifyDiskSpecResponse creates a response to parse from ModifyDiskSpec response

type ModifyEntitlementRequest ¶

type ModifyEntitlementRequest struct {
	*requests.RpcRequest
	EndUserId *[]string `position:"Query" name:"EndUserId"  type:"Repeated"`
	DesktopId string    `position:"Query" name:"DesktopId"`
}

ModifyEntitlementRequest is the request struct for api ModifyEntitlement

func CreateModifyEntitlementRequest ¶

func CreateModifyEntitlementRequest() (request *ModifyEntitlementRequest)

CreateModifyEntitlementRequest creates a request to invoke ModifyEntitlement API

type ModifyEntitlementResponse ¶

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

ModifyEntitlementResponse is the response struct for api ModifyEntitlement

func CreateModifyEntitlementResponse ¶

func CreateModifyEntitlementResponse() (response *ModifyEntitlementResponse)

CreateModifyEntitlementResponse creates a response to parse from ModifyEntitlement response

type ModifyImageAttributeRequest ¶

type ModifyImageAttributeRequest struct {
	*requests.RpcRequest
	ImageId     string `position:"Query" name:"ImageId"`
	Description string `position:"Query" name:"Description"`
	Name        string `position:"Query" name:"Name"`
}

ModifyImageAttributeRequest is the request struct for api ModifyImageAttribute

func CreateModifyImageAttributeRequest ¶

func CreateModifyImageAttributeRequest() (request *ModifyImageAttributeRequest)

CreateModifyImageAttributeRequest creates a request to invoke ModifyImageAttribute API

type ModifyImageAttributeResponse ¶

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

ModifyImageAttributeResponse is the response struct for api ModifyImageAttribute

func CreateModifyImageAttributeResponse ¶

func CreateModifyImageAttributeResponse() (response *ModifyImageAttributeResponse)

CreateModifyImageAttributeResponse creates a response to parse from ModifyImageAttribute response

type ModifyImagePermissionRequest ¶

type ModifyImagePermissionRequest struct {
	*requests.RpcRequest
	ImageId       string    `position:"Query" name:"ImageId"`
	AddAccount    *[]string `position:"Query" name:"AddAccount"  type:"Repeated"`
	RemoveAccount *[]string `position:"Query" name:"RemoveAccount"  type:"Repeated"`
}

ModifyImagePermissionRequest is the request struct for api ModifyImagePermission

func CreateModifyImagePermissionRequest ¶

func CreateModifyImagePermissionRequest() (request *ModifyImagePermissionRequest)

CreateModifyImagePermissionRequest creates a request to invoke ModifyImagePermission API

type ModifyImagePermissionResponse ¶

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

ModifyImagePermissionResponse is the response struct for api ModifyImagePermission

func CreateModifyImagePermissionResponse ¶

func CreateModifyImagePermissionResponse() (response *ModifyImagePermissionResponse)

CreateModifyImagePermissionResponse creates a response to parse from ModifyImagePermission response

type ModifyNASDefaultMountTargetRequest ¶

type ModifyNASDefaultMountTargetRequest struct {
	*requests.RpcRequest
	MountTargetDomain string `position:"Query" name:"MountTargetDomain"`
	FileSystemId      string `position:"Query" name:"FileSystemId"`
}

ModifyNASDefaultMountTargetRequest is the request struct for api ModifyNASDefaultMountTarget

func CreateModifyNASDefaultMountTargetRequest ¶

func CreateModifyNASDefaultMountTargetRequest() (request *ModifyNASDefaultMountTargetRequest)

CreateModifyNASDefaultMountTargetRequest creates a request to invoke ModifyNASDefaultMountTarget API

type ModifyNASDefaultMountTargetResponse ¶

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

ModifyNASDefaultMountTargetResponse is the response struct for api ModifyNASDefaultMountTarget

func CreateModifyNASDefaultMountTargetResponse ¶

func CreateModifyNASDefaultMountTargetResponse() (response *ModifyNASDefaultMountTargetResponse)

CreateModifyNASDefaultMountTargetResponse creates a response to parse from ModifyNASDefaultMountTarget response

type ModifyNetworkPackageBandwidthRequest ¶

type ModifyNetworkPackageBandwidthRequest struct {
	*requests.RpcRequest
	AutoPay          requests.Boolean `position:"Query" name:"AutoPay"`
	Bandwidth        requests.Integer `position:"Query" name:"Bandwidth"`
	NetworkPackageId string           `position:"Query" name:"NetworkPackageId"`
	PromotionId      string           `position:"Query" name:"PromotionId"`
}

ModifyNetworkPackageBandwidthRequest is the request struct for api ModifyNetworkPackageBandwidth

func CreateModifyNetworkPackageBandwidthRequest ¶

func CreateModifyNetworkPackageBandwidthRequest() (request *ModifyNetworkPackageBandwidthRequest)

CreateModifyNetworkPackageBandwidthRequest creates a request to invoke ModifyNetworkPackageBandwidth API

type ModifyNetworkPackageBandwidthResponse ¶

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

ModifyNetworkPackageBandwidthResponse is the response struct for api ModifyNetworkPackageBandwidth

func CreateModifyNetworkPackageBandwidthResponse ¶

func CreateModifyNetworkPackageBandwidthResponse() (response *ModifyNetworkPackageBandwidthResponse)

CreateModifyNetworkPackageBandwidthResponse creates a response to parse from ModifyNetworkPackageBandwidth response

type ModifyNetworkPackageEnabledRequest ¶

type ModifyNetworkPackageEnabledRequest struct {
	*requests.RpcRequest
	NetworkPackageId string           `position:"Query" name:"NetworkPackageId"`
	Enabled          requests.Boolean `position:"Query" name:"Enabled"`
}

ModifyNetworkPackageEnabledRequest is the request struct for api ModifyNetworkPackageEnabled

func CreateModifyNetworkPackageEnabledRequest ¶

func CreateModifyNetworkPackageEnabledRequest() (request *ModifyNetworkPackageEnabledRequest)

CreateModifyNetworkPackageEnabledRequest creates a request to invoke ModifyNetworkPackageEnabled API

type ModifyNetworkPackageEnabledResponse ¶

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

ModifyNetworkPackageEnabledResponse is the response struct for api ModifyNetworkPackageEnabled

func CreateModifyNetworkPackageEnabledResponse ¶

func CreateModifyNetworkPackageEnabledResponse() (response *ModifyNetworkPackageEnabledResponse)

CreateModifyNetworkPackageEnabledResponse creates a response to parse from ModifyNetworkPackageEnabled response

type ModifyOfficeSiteAttributeRequest ¶

type ModifyOfficeSiteAttributeRequest struct {
	*requests.RpcRequest
	OfficeSiteId         string           `position:"Query" name:"OfficeSiteId"`
	DesktopAccessType    string           `position:"Query" name:"DesktopAccessType"`
	OfficeSiteName       string           `position:"Query" name:"OfficeSiteName"`
	NeedVerifyLoginRisk  requests.Boolean `position:"Query" name:"NeedVerifyLoginRisk"`
	NeedVerifyZeroDevice requests.Boolean `position:"Query" name:"NeedVerifyZeroDevice"`
}

ModifyOfficeSiteAttributeRequest is the request struct for api ModifyOfficeSiteAttribute

func CreateModifyOfficeSiteAttributeRequest ¶

func CreateModifyOfficeSiteAttributeRequest() (request *ModifyOfficeSiteAttributeRequest)

CreateModifyOfficeSiteAttributeRequest creates a request to invoke ModifyOfficeSiteAttribute API

type ModifyOfficeSiteAttributeResponse ¶

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

ModifyOfficeSiteAttributeResponse is the response struct for api ModifyOfficeSiteAttribute

func CreateModifyOfficeSiteAttributeResponse ¶

func CreateModifyOfficeSiteAttributeResponse() (response *ModifyOfficeSiteAttributeResponse)

CreateModifyOfficeSiteAttributeResponse creates a response to parse from ModifyOfficeSiteAttribute response

type ModifyOfficeSiteCrossDesktopAccessRequest ¶

type ModifyOfficeSiteCrossDesktopAccessRequest struct {
	*requests.RpcRequest
	OfficeSiteId             string           `position:"Query" name:"OfficeSiteId"`
	EnableCrossDesktopAccess requests.Boolean `position:"Query" name:"EnableCrossDesktopAccess"`
}

ModifyOfficeSiteCrossDesktopAccessRequest is the request struct for api ModifyOfficeSiteCrossDesktopAccess

func CreateModifyOfficeSiteCrossDesktopAccessRequest ¶

func CreateModifyOfficeSiteCrossDesktopAccessRequest() (request *ModifyOfficeSiteCrossDesktopAccessRequest)

CreateModifyOfficeSiteCrossDesktopAccessRequest creates a request to invoke ModifyOfficeSiteCrossDesktopAccess API

type ModifyOfficeSiteCrossDesktopAccessResponse ¶

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

ModifyOfficeSiteCrossDesktopAccessResponse is the response struct for api ModifyOfficeSiteCrossDesktopAccess

func CreateModifyOfficeSiteCrossDesktopAccessResponse ¶

func CreateModifyOfficeSiteCrossDesktopAccessResponse() (response *ModifyOfficeSiteCrossDesktopAccessResponse)

CreateModifyOfficeSiteCrossDesktopAccessResponse creates a response to parse from ModifyOfficeSiteCrossDesktopAccess response

type ModifyOfficeSiteMfaEnabledRequest ¶

type ModifyOfficeSiteMfaEnabledRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	MfaEnabled   requests.Boolean `position:"Query" name:"MfaEnabled"`
}

ModifyOfficeSiteMfaEnabledRequest is the request struct for api ModifyOfficeSiteMfaEnabled

func CreateModifyOfficeSiteMfaEnabledRequest ¶

func CreateModifyOfficeSiteMfaEnabledRequest() (request *ModifyOfficeSiteMfaEnabledRequest)

CreateModifyOfficeSiteMfaEnabledRequest creates a request to invoke ModifyOfficeSiteMfaEnabled API

type ModifyOfficeSiteMfaEnabledResponse ¶

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

ModifyOfficeSiteMfaEnabledResponse is the response struct for api ModifyOfficeSiteMfaEnabled

func CreateModifyOfficeSiteMfaEnabledResponse ¶

func CreateModifyOfficeSiteMfaEnabledResponse() (response *ModifyOfficeSiteMfaEnabledResponse)

CreateModifyOfficeSiteMfaEnabledResponse creates a response to parse from ModifyOfficeSiteMfaEnabled response

type ModifyOperateVulRequest ¶

type ModifyOperateVulRequest struct {
	*requests.RpcRequest
	Reason      string                     `position:"Query" name:"Reason"`
	Type        string                     `position:"Query" name:"Type"`
	VulInfo     *[]ModifyOperateVulVulInfo `position:"Query" name:"VulInfo"  type:"Repeated"`
	OperateType string                     `position:"Query" name:"OperateType"`
}

ModifyOperateVulRequest is the request struct for api ModifyOperateVul

func CreateModifyOperateVulRequest ¶

func CreateModifyOperateVulRequest() (request *ModifyOperateVulRequest)

CreateModifyOperateVulRequest creates a request to invoke ModifyOperateVul API

type ModifyOperateVulResponse ¶

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

ModifyOperateVulResponse is the response struct for api ModifyOperateVul

func CreateModifyOperateVulResponse ¶

func CreateModifyOperateVulResponse() (response *ModifyOperateVulResponse)

CreateModifyOperateVulResponse creates a response to parse from ModifyOperateVul response

type ModifyOperateVulVulInfo ¶

type ModifyOperateVulVulInfo struct {
	Name      string `name:"Name"`
	DesktopId string `name:"DesktopId"`
	Tag       string `name:"Tag"`
}

ModifyOperateVulVulInfo is a repeated param struct in ModifyOperateVulRequest

type ModifyPolicyGroupAuthorizeAccessPolicyRule ¶

type ModifyPolicyGroupAuthorizeAccessPolicyRule struct {
	Description string `name:"Description"`
	CidrIp      string `name:"CidrIp"`
}

ModifyPolicyGroupAuthorizeAccessPolicyRule is a repeated param struct in ModifyPolicyGroupRequest

type ModifyPolicyGroupAuthorizeSecurityPolicyRule ¶

type ModifyPolicyGroupAuthorizeSecurityPolicyRule struct {
	PortRange   string `name:"PortRange"`
	IpProtocol  string `name:"IpProtocol"`
	Description string `name:"Description"`
	Type        string `name:"Type"`
	Priority    string `name:"Priority"`
	CidrIp      string `name:"CidrIp"`
	Policy      string `name:"Policy"`
}

ModifyPolicyGroupAuthorizeSecurityPolicyRule is a repeated param struct in ModifyPolicyGroupRequest

type ModifyPolicyGroupClientType ¶

type ModifyPolicyGroupClientType struct {
	ClientType string `name:"ClientType"`
	Status     string `name:"Status"`
}

ModifyPolicyGroupClientType is a repeated param struct in ModifyPolicyGroupRequest

type ModifyPolicyGroupRequest ¶

type ModifyPolicyGroupRequest struct {
	*requests.RpcRequest
	WatermarkCustomText         string                                          `position:"Query" name:"WatermarkCustomText"`
	PreemptLogin                string                                          `position:"Query" name:"PreemptLogin"`
	ClientType                  *[]ModifyPolicyGroupClientType                  `position:"Query" name:"ClientType"  type:"Repeated"`
	RevokeSecurityPolicyRule    *[]ModifyPolicyGroupRevokeSecurityPolicyRule    `position:"Query" name:"RevokeSecurityPolicyRule"  type:"Repeated"`
	UsbSupplyRedirectRule       *[]ModifyPolicyGroupUsbSupplyRedirectRule       `position:"Query" name:"UsbSupplyRedirectRule"  type:"Repeated"`
	PrinterRedirection          string                                          `position:"Query" name:"PrinterRedirection"`
	PreemptLoginUser            *[]string                                       `position:"Query" name:"PreemptLoginUser"  type:"Repeated"`
	DomainList                  string                                          `position:"Query" name:"DomainList"`
	NetRedirect                 string                                          `position:"Query" name:"NetRedirect"`
	LocalDrive                  string                                          `position:"Query" name:"LocalDrive"`
	AuthorizeSecurityPolicyRule *[]ModifyPolicyGroupAuthorizeSecurityPolicyRule `position:"Query" name:"AuthorizeSecurityPolicyRule"  type:"Repeated"`
	Recording                   string                                          `position:"Query" name:"Recording"`
	Clipboard                   string                                          `position:"Query" name:"Clipboard"`
	RecordingFps                requests.Integer                                `position:"Query" name:"RecordingFps"`
	UsbRedirect                 string                                          `position:"Query" name:"UsbRedirect"`
	WatermarkType               string                                          `position:"Query" name:"WatermarkType"`
	RecordingStartTime          string                                          `position:"Query" name:"RecordingStartTime"`
	RevokeAccessPolicyRule      *[]ModifyPolicyGroupRevokeAccessPolicyRule      `position:"Query" name:"RevokeAccessPolicyRule"  type:"Repeated"`
	Watermark                   string                                          `position:"Query" name:"Watermark"`
	CameraRedirect              string                                          `position:"Query" name:"CameraRedirect"`
	Html5Access                 string                                          `position:"Query" name:"Html5Access"`
	GpuAcceleration             string                                          `position:"Query" name:"GpuAcceleration"`
	Html5FileTransfer           string                                          `position:"Query" name:"Html5FileTransfer"`
	AuthorizeAccessPolicyRule   *[]ModifyPolicyGroupAuthorizeAccessPolicyRule   `position:"Query" name:"AuthorizeAccessPolicyRule"  type:"Repeated"`
	VisualQuality               string                                          `position:"Query" name:"VisualQuality"`
	WatermarkTransparency       string                                          `position:"Query" name:"WatermarkTransparency"`
	Name                        string                                          `position:"Query" name:"Name"`
	RecordingEndTime            string                                          `position:"Query" name:"RecordingEndTime"`
	PolicyGroupId               string                                          `position:"Query" name:"PolicyGroupId"`
}

ModifyPolicyGroupRequest is the request struct for api ModifyPolicyGroup

func CreateModifyPolicyGroupRequest ¶

func CreateModifyPolicyGroupRequest() (request *ModifyPolicyGroupRequest)

CreateModifyPolicyGroupRequest creates a request to invoke ModifyPolicyGroup API

type ModifyPolicyGroupResponse ¶

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

ModifyPolicyGroupResponse is the response struct for api ModifyPolicyGroup

func CreateModifyPolicyGroupResponse ¶

func CreateModifyPolicyGroupResponse() (response *ModifyPolicyGroupResponse)

CreateModifyPolicyGroupResponse creates a response to parse from ModifyPolicyGroup response

type ModifyPolicyGroupRevokeAccessPolicyRule ¶

type ModifyPolicyGroupRevokeAccessPolicyRule struct {
	Description string `name:"Description"`
	CidrIp      string `name:"CidrIp"`
}

ModifyPolicyGroupRevokeAccessPolicyRule is a repeated param struct in ModifyPolicyGroupRequest

type ModifyPolicyGroupRevokeSecurityPolicyRule ¶

type ModifyPolicyGroupRevokeSecurityPolicyRule struct {
	PortRange   string `name:"PortRange"`
	IpProtocol  string `name:"IpProtocol"`
	Description string `name:"Description"`
	Type        string `name:"Type"`
	Priority    string `name:"Priority"`
	CidrIp      string `name:"CidrIp"`
	Policy      string `name:"Policy"`
}

ModifyPolicyGroupRevokeSecurityPolicyRule is a repeated param struct in ModifyPolicyGroupRequest

type ModifyPolicyGroupUsbSupplyRedirectRule ¶

type ModifyPolicyGroupUsbSupplyRedirectRule struct {
	ProductId       string `name:"ProductId"`
	DeviceSubclass  string `name:"DeviceSubclass"`
	UsbRedirectType string `name:"UsbRedirectType"`
	VendorId        string `name:"VendorId"`
	Description     string `name:"Description"`
	DeviceClass     string `name:"DeviceClass"`
	UsbRuleType     string `name:"UsbRuleType"`
}

ModifyPolicyGroupUsbSupplyRedirectRule is a repeated param struct in ModifyPolicyGroupRequest

type ModifyResult ¶

type ModifyResult struct {
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	DesktopId string `json:"DesktopId" xml:"DesktopId"`
}

ModifyResult is a nested struct in ecd response

type ModifyResults ¶

type ModifyResults struct {
	ModifyResult []ModifyResult `json:"ModifyResult" xml:"ModifyResult"`
}

ModifyResults is a nested struct in ecd response

type ModifyUserEntitlementRequest ¶

type ModifyUserEntitlementRequest struct {
	*requests.RpcRequest
	AuthorizeDesktopId *[]string `position:"Query" name:"AuthorizeDesktopId"  type:"Repeated"`
	RevokeDesktopId    *[]string `position:"Query" name:"RevokeDesktopId"  type:"Repeated"`
	EndUserId          *[]string `position:"Query" name:"EndUserId"  type:"Repeated"`
}

ModifyUserEntitlementRequest is the request struct for api ModifyUserEntitlement

func CreateModifyUserEntitlementRequest ¶

func CreateModifyUserEntitlementRequest() (request *ModifyUserEntitlementRequest)

CreateModifyUserEntitlementRequest creates a request to invoke ModifyUserEntitlement API

type ModifyUserEntitlementResponse ¶

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

ModifyUserEntitlementResponse is the response struct for api ModifyUserEntitlement

func CreateModifyUserEntitlementResponse ¶

func CreateModifyUserEntitlementResponse() (response *ModifyUserEntitlementResponse)

CreateModifyUserEntitlementResponse creates a response to parse from ModifyUserEntitlement response

type ModifyUserToDesktopGroupRequest ¶

type ModifyUserToDesktopGroupRequest struct {
	*requests.RpcRequest
	OldEndUserIds  *[]string `position:"Query" name:"OldEndUserIds"  type:"Repeated"`
	DesktopGroupId string    `position:"Query" name:"DesktopGroupId"`
	NewEndUserIds  *[]string `position:"Query" name:"NewEndUserIds"  type:"Repeated"`
}

ModifyUserToDesktopGroupRequest is the request struct for api ModifyUserToDesktopGroup

func CreateModifyUserToDesktopGroupRequest ¶

func CreateModifyUserToDesktopGroupRequest() (request *ModifyUserToDesktopGroupRequest)

CreateModifyUserToDesktopGroupRequest creates a request to invoke ModifyUserToDesktopGroup API

type ModifyUserToDesktopGroupResponse ¶

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

ModifyUserToDesktopGroupResponse is the response struct for api ModifyUserToDesktopGroup

func CreateModifyUserToDesktopGroupResponse ¶

func CreateModifyUserToDesktopGroupResponse() (response *ModifyUserToDesktopGroupResponse)

CreateModifyUserToDesktopGroupResponse creates a response to parse from ModifyUserToDesktopGroup response

type NetworkPackage ¶

type NetworkPackage struct {
	NetworkPackageId     string   `json:"NetworkPackageId" xml:"NetworkPackageId"`
	Bandwidth            int      `json:"Bandwidth" xml:"Bandwidth"`
	ExpiredTime          string   `json:"ExpiredTime" xml:"ExpiredTime"`
	CreateTime           string   `json:"CreateTime" xml:"CreateTime"`
	OfficeSiteId         string   `json:"OfficeSiteId" xml:"OfficeSiteId"`
	InternetChargeType   string   `json:"InternetChargeType" xml:"InternetChargeType"`
	NetworkPackageStatus string   `json:"NetworkPackageStatus" xml:"NetworkPackageStatus"`
	OfficeSiteName       string   `json:"OfficeSiteName" xml:"OfficeSiteName"`
	EipAddresses         []string `json:"EipAddresses" xml:"EipAddresses"`
}

NetworkPackage is a nested struct in ecd response

type NetworkPackages ¶

type NetworkPackages struct {
	NetworkPackage []NetworkPackage `json:"NetworkPackage" xml:"NetworkPackage"`
}

NetworkPackages is a nested struct in ecd response

type OUNames ¶

type OUNames struct {
	OuName []OuName `json:"ouName" xml:"ouName"`
}

OUNames is a nested struct in ecd response

type OfficeSite ¶

type OfficeSite struct {
	Status                   string        `json:"Status" xml:"Status"`
	CreationTime             string        `json:"CreationTime" xml:"CreationTime"`
	VpcId                    string        `json:"VpcId" xml:"VpcId"`
	VpcType                  string        `json:"VpcType" xml:"VpcType"`
	EnableAdminAccess        bool          `json:"EnableAdminAccess" xml:"EnableAdminAccess"`
	EnableCrossDesktopAccess bool          `json:"EnableCrossDesktopAccess" xml:"EnableCrossDesktopAccess"`
	DesktopVpcEndpoint       string        `json:"DesktopVpcEndpoint" xml:"DesktopVpcEndpoint"`
	DesktopAccessType        string        `json:"DesktopAccessType" xml:"DesktopAccessType"`
	DomainName               string        `json:"DomainName" xml:"DomainName"`
	SsoEnabled               bool          `json:"SsoEnabled" xml:"SsoEnabled"`
	CidrBlock                string        `json:"CidrBlock" xml:"CidrBlock"`
	Bandwidth                int           `json:"Bandwidth" xml:"Bandwidth"`
	TrustPassword            string        `json:"TrustPassword" xml:"TrustPassword"`
	Name                     string        `json:"Name" xml:"Name"`
	EnableInternetAccess     bool          `json:"EnableInternetAccess" xml:"EnableInternetAccess"`
	DomainPassword           string        `json:"DomainPassword" xml:"DomainPassword"`
	CustomSecurityGroupId    string        `json:"CustomSecurityGroupId" xml:"CustomSecurityGroupId"`
	OuName                   string        `json:"OuName" xml:"OuName"`
	DomainUserName           string        `json:"DomainUserName" xml:"DomainUserName"`
	SubDomainName            string        `json:"SubDomainName" xml:"SubDomainName"`
	OfficeSiteId             string        `json:"OfficeSiteId" xml:"OfficeSiteId"`
	CenId                    string        `json:"CenId" xml:"CenId"`
	MfaEnabled               bool          `json:"MfaEnabled" xml:"MfaEnabled"`
	NetworkPackageId         string        `json:"NetworkPackageId" xml:"NetworkPackageId"`
	DnsUserName              string        `json:"DnsUserName" xml:"DnsUserName"`
	OfficeSiteType           string        `json:"OfficeSiteType" xml:"OfficeSiteType"`
	NeedVerifyLoginRisk      bool          `json:"NeedVerifyLoginRisk" xml:"NeedVerifyLoginRisk"`
	DesktopCount             int64         `json:"DesktopCount" xml:"DesktopCount"`
	NeedVerifyZeroDevice     bool          `json:"NeedVerifyZeroDevice" xml:"NeedVerifyZeroDevice"`
	CloudBoxOfficeSite       bool          `json:"CloudBoxOfficeSite" xml:"CloudBoxOfficeSite"`
	SsoType                  string        `json:"SsoType" xml:"SsoType"`
	ProtocolType             string        `json:"ProtocolType" xml:"ProtocolType"`
	AdHostname               string        `json:"AdHostname" xml:"AdHostname"`
	VSwitchIds               []string      `json:"VSwitchIds" xml:"VSwitchIds"`
	FileSystemIds            []string      `json:"FileSystemIds" xml:"FileSystemIds"`
	SubDnsAddress            []string      `json:"SubDnsAddress" xml:"SubDnsAddress"`
	DnsAddress               []string      `json:"DnsAddress" xml:"DnsAddress"`
	ADConnectors             []ADConnector `json:"ADConnectors" xml:"ADConnectors"`
	Logs                     []Log         `json:"Logs" xml:"Logs"`
}

OfficeSite is a nested struct in ecd response

type OfficeSiteOverviewResult ¶

type OfficeSiteOverviewResult struct {
	OfficeSiteStatus            string `json:"OfficeSiteStatus" xml:"OfficeSiteStatus"`
	TotalEdsCount               int    `json:"TotalEdsCount" xml:"TotalEdsCount"`
	TotalEdsCountForGroup       int    `json:"TotalEdsCountForGroup" xml:"TotalEdsCountForGroup"`
	WillExpiredEdsCount         int    `json:"WillExpiredEdsCount" xml:"WillExpiredEdsCount"`
	WillExpiredEdsCountForGroup int    `json:"WillExpiredEdsCountForGroup" xml:"WillExpiredEdsCountForGroup"`
	OfficeSiteId                string `json:"OfficeSiteId" xml:"OfficeSiteId"`
	RunningEdsCount             int    `json:"RunningEdsCount" xml:"RunningEdsCount"`
	RunningEdsCountForGroup     int    `json:"RunningEdsCountForGroup" xml:"RunningEdsCountForGroup"`
	OfficeSiteName              string `json:"OfficeSiteName" xml:"OfficeSiteName"`
	VpcType                     string `json:"VpcType" xml:"VpcType"`
	HasExpiredEdsCount          int    `json:"HasExpiredEdsCount" xml:"HasExpiredEdsCount"`
	HasExpiredEdsCountForGroup  int    `json:"HasExpiredEdsCountForGroup" xml:"HasExpiredEdsCountForGroup"`
	RegionId                    string `json:"RegionId" xml:"RegionId"`
}

OfficeSiteOverviewResult is a nested struct in ecd response

type OfficeSiteOverviewResults ¶

type OfficeSiteOverviewResults struct {
	OfficeSiteOverviewResult []OfficeSiteOverviewResult `json:"OfficeSiteOverviewResult" xml:"OfficeSiteOverviewResult"`
}

OfficeSiteOverviewResults is a nested struct in ecd response

type OfficeSites ¶

type OfficeSites struct {
	OfficeSite []OfficeSite `json:"OfficeSite" xml:"OfficeSite"`
}

OfficeSites is a nested struct in ecd response

type OperateVulsRequest ¶

type OperateVulsRequest struct {
	*requests.RpcRequest
	Reason       string           `position:"Query" name:"Reason"`
	Precondition requests.Integer `position:"Query" name:"Precondition"`
	Type         string           `position:"Query" name:"Type"`
	VulName      *[]string        `position:"Query" name:"VulName"  type:"Repeated"`
	OperateType  string           `position:"Query" name:"OperateType"`
	DesktopId    *[]string        `position:"Query" name:"DesktopId"  type:"Repeated"`
}

OperateVulsRequest is the request struct for api OperateVuls

func CreateOperateVulsRequest ¶

func CreateOperateVulsRequest() (request *OperateVulsRequest)

CreateOperateVulsRequest creates a request to invoke OperateVuls API

type OperateVulsResponse ¶

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

OperateVulsResponse is the response struct for api OperateVuls

func CreateOperateVulsResponse ¶

func CreateOperateVulsResponse() (response *OperateVulsResponse)

CreateOperateVulsResponse creates a response to parse from OperateVuls response

type OrderIds ¶

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

OrderIds is a nested struct in ecd response

type OuName ¶

type OuName struct {
	OfficeSiteId string `json:"OfficeSiteId" xml:"OfficeSiteId"`
	OUName       string `json:"OUName" xml:"OUName"`
}

OuName is a nested struct in ecd response

type PackageId ¶

type PackageId struct {
	PackageId string `json:"PackageId" xml:"PackageId"`
}

PackageId is a nested struct in ecd response

type PackageIds ¶

type PackageIds struct {
	PackageId []PackageId `json:"PackageId" xml:"PackageId"`
}

PackageIds is a nested struct in ecd response

type PaidDesktop ¶

type PaidDesktop struct {
	EndUserId        string   `json:"EndUserId" xml:"EndUserId"`
	DesktopStatus    string   `json:"DesktopStatus" xml:"DesktopStatus"`
	DesktopName      string   `json:"DesktopName" xml:"DesktopName"`
	ConnectionStatus string   `json:"ConnectionStatus" xml:"ConnectionStatus"`
	DesktopId        string   `json:"DesktopId" xml:"DesktopId"`
	EndUserName      string   `json:"EndUserName" xml:"EndUserName"`
	ManagementFlag   string   `json:"ManagementFlag" xml:"ManagementFlag"`
	ResetTime        string   `json:"ResetTime" xml:"ResetTime"`
	ImageId          string   `json:"ImageId" xml:"ImageId"`
	ImageName        string   `json:"ImageName" xml:"ImageName"`
	SystemDiskSize   int      `json:"SystemDiskSize" xml:"SystemDiskSize"`
	OsType           string   `json:"OsType" xml:"OsType"`
	GpuDriverVersion string   `json:"GpuDriverVersion" xml:"GpuDriverVersion"`
	DiskType         string   `json:"DiskType" xml:"DiskType"`
	EndUserIds       []string `json:"EndUserIds" xml:"EndUserIds"`
	EndUserNames     []string `json:"EndUserNames" xml:"EndUserNames"`
}

PaidDesktop is a nested struct in ecd response

type PaidDesktops ¶

type PaidDesktops struct {
	PaidDesktop []PaidDesktop `json:"PaidDesktop" xml:"PaidDesktop"`
}

PaidDesktops is a nested struct in ecd response

type PatchItem ¶

type PatchItem struct {
	Name      string `json:"Name" xml:"Name"`
	AliasName string `json:"AliasName" xml:"AliasName"`
}

PatchItem is a nested struct in ecd response

type PatchList ¶

type PatchList struct {
	PatchItem []PatchItem `json:"PatchItem" xml:"PatchItem"`
}

PatchList is a nested struct in ecd response

type PostPaidDesktop ¶

type PostPaidDesktop struct {
	CreateDuration   string   `json:"CreateDuration" xml:"CreateDuration"`
	EndUserId        string   `json:"EndUserId" xml:"EndUserId"`
	DesktopStatus    string   `json:"DesktopStatus" xml:"DesktopStatus"`
	CreateTime       string   `json:"CreateTime" xml:"CreateTime"`
	ReleaseTime      string   `json:"ReleaseTime" xml:"ReleaseTime"`
	DesktopName      string   `json:"DesktopName" xml:"DesktopName"`
	ConnectionStatus string   `json:"ConnectionStatus" xml:"ConnectionStatus"`
	DesktopId        string   `json:"DesktopId" xml:"DesktopId"`
	EndUserName      string   `json:"EndUserName" xml:"EndUserName"`
	ManagementFlag   string   `json:"ManagementFlag" xml:"ManagementFlag"`
	ResetTime        string   `json:"ResetTime" xml:"ResetTime"`
	ImageId          string   `json:"ImageId" xml:"ImageId"`
	ImageName        string   `json:"ImageName" xml:"ImageName"`
	SystemDiskSize   int      `json:"SystemDiskSize" xml:"SystemDiskSize"`
	OsType           string   `json:"OsType" xml:"OsType"`
	GpuDriverVersion string   `json:"GpuDriverVersion" xml:"GpuDriverVersion"`
	DiskType         string   `json:"DiskType" xml:"DiskType"`
	EndUserIds       []string `json:"EndUserIds" xml:"EndUserIds"`
	EndUserNames     []string `json:"EndUserNames" xml:"EndUserNames"`
}

PostPaidDesktop is a nested struct in ecd response

type PostPaidDesktops ¶

type PostPaidDesktops struct {
	PostPaidDesktop []PostPaidDesktop `json:"PostPaidDesktop" xml:"PostPaidDesktop"`
}

PostPaidDesktops is a nested struct in ecd response

type PreemptLoginUsers ¶

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

PreemptLoginUsers is a nested struct in ecd response

type PropertyValues ¶

type PropertyValues struct {
	PropertyValueId int64  `json:"PropertyValueId" xml:"PropertyValueId"`
	PropertyValue   string `json:"PropertyValue" xml:"PropertyValue"`
}

PropertyValues is a nested struct in ecd response

type PropertyValuesInDescribeUsersInGroup ¶

type PropertyValuesInDescribeUsersInGroup struct {
	PropertyValues []PropertyValues `json:"propertyValues" xml:"propertyValues"`
}

PropertyValuesInDescribeUsersInGroup is a nested struct in ecd response

type QuaraFile ¶

type QuaraFile struct {
	Status      string `json:"Status" xml:"Status"`
	EventName   string `json:"EventName" xml:"EventName"`
	EventType   string `json:"EventType" xml:"EventType"`
	Path        string `json:"Path" xml:"Path"`
	DesktopName string `json:"DesktopName" xml:"DesktopName"`
	Md5         string `json:"Md5" xml:"Md5"`
	Tag         string `json:"Tag" xml:"Tag"`
	DesktopId   string `json:"DesktopId" xml:"DesktopId"`
	Id          int    `json:"Id" xml:"Id"`
	ModifyTime  string `json:"ModifyTime" xml:"ModifyTime"`
}

QuaraFile is a nested struct in ecd response

type QuaraFiles ¶

type QuaraFiles struct {
	QuaraFile []QuaraFile `json:"QuaraFile" xml:"QuaraFile"`
}

QuaraFiles is a nested struct in ecd response

type RebootDesktopsRequest ¶

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

RebootDesktopsRequest is the request struct for api RebootDesktops

func CreateRebootDesktopsRequest ¶

func CreateRebootDesktopsRequest() (request *RebootDesktopsRequest)

CreateRebootDesktopsRequest creates a request to invoke RebootDesktops API

type RebootDesktopsResponse ¶

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

RebootDesktopsResponse is the response struct for api RebootDesktops

func CreateRebootDesktopsResponse ¶

func CreateRebootDesktopsResponse() (response *RebootDesktopsResponse)

CreateRebootDesktopsResponse creates a response to parse from RebootDesktops response

type RebuildDesktopsRequest ¶

type RebuildDesktopsRequest struct {
	*requests.RpcRequest
	ImageId   string    `position:"Query" name:"ImageId"`
	DesktopId *[]string `position:"Query" name:"DesktopId"  type:"Repeated"`
}

RebuildDesktopsRequest is the request struct for api RebuildDesktops

func CreateRebuildDesktopsRequest ¶

func CreateRebuildDesktopsRequest() (request *RebuildDesktopsRequest)

CreateRebuildDesktopsRequest creates a request to invoke RebuildDesktops API

type RebuildDesktopsResponse ¶

type RebuildDesktopsResponse struct {
	*responses.BaseResponse
	RequestId      string          `json:"RequestId" xml:"RequestId"`
	RebuildResults []RebuildResult `json:"RebuildResults" xml:"RebuildResults"`
}

RebuildDesktopsResponse is the response struct for api RebuildDesktops

func CreateRebuildDesktopsResponse ¶

func CreateRebuildDesktopsResponse() (response *RebuildDesktopsResponse)

CreateRebuildDesktopsResponse creates a response to parse from RebuildDesktops response

type RebuildResult ¶

type RebuildResult struct {
	Code      string `json:"Code" xml:"Code"`
	Message   string `json:"Message" xml:"Message"`
	DesktopId string `json:"DesktopId" xml:"DesktopId"`
}

RebuildResult is a nested struct in ecd response

type RebuildResults ¶

type RebuildResults struct {
	RebuildResult []RebuildResult `json:"RebuildResult" xml:"RebuildResult"`
}

RebuildResults is a nested struct in ecd response

type Recording ¶

type Recording struct {
	EndTime       string   `json:"EndTime" xml:"EndTime"`
	FilePath      string   `json:"FilePath" xml:"FilePath"`
	StartTime     string   `json:"StartTime" xml:"StartTime"`
	RecordingType string   `json:"RecordingType" xml:"RecordingType"`
	RecordingSize int      `json:"RecordingSize" xml:"RecordingSize"`
	DesktopId     string   `json:"DesktopId" xml:"DesktopId"`
	EndUserIds    []string `json:"EndUserIds" xml:"EndUserIds"`
}

Recording is a nested struct in ecd response

type Recordings ¶

type Recordings struct {
	Recording []Recording `json:"Recording" xml:"Recording"`
}

Recordings is a nested struct in ecd response

type Region ¶

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

Region is a nested struct in ecd response

type Regions ¶

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

Regions is a nested struct in ecd response

type RemoveUserFromDesktopGroupRequest ¶

type RemoveUserFromDesktopGroupRequest struct {
	*requests.RpcRequest
	EndUserIds      *[]string `position:"Query" name:"EndUserIds"  type:"Repeated"`
	DesktopGroupId  string    `position:"Query" name:"DesktopGroupId"`
	DesktopGroupIds *[]string `position:"Query" name:"DesktopGroupIds"  type:"Repeated"`
}

RemoveUserFromDesktopGroupRequest is the request struct for api RemoveUserFromDesktopGroup

func CreateRemoveUserFromDesktopGroupRequest ¶

func CreateRemoveUserFromDesktopGroupRequest() (request *RemoveUserFromDesktopGroupRequest)

CreateRemoveUserFromDesktopGroupRequest creates a request to invoke RemoveUserFromDesktopGroup API

type RemoveUserFromDesktopGroupResponse ¶

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

RemoveUserFromDesktopGroupResponse is the response struct for api RemoveUserFromDesktopGroup

func CreateRemoveUserFromDesktopGroupResponse ¶

func CreateRemoveUserFromDesktopGroupResponse() (response *RemoveUserFromDesktopGroupResponse)

CreateRemoveUserFromDesktopGroupResponse creates a response to parse from RemoveUserFromDesktopGroup response

type RenewDesktopsRequest ¶

type RenewDesktopsRequest struct {
	*requests.RpcRequest
	Period      requests.Integer `position:"Query" name:"Period"`
	AutoPay     requests.Boolean `position:"Query" name:"AutoPay"`
	PromotionId string           `position:"Query" name:"PromotionId"`
	PeriodUnit  string           `position:"Query" name:"PeriodUnit"`
	DesktopId   *[]string        `position:"Query" name:"DesktopId"  type:"Repeated"`
}

RenewDesktopsRequest is the request struct for api RenewDesktops

func CreateRenewDesktopsRequest ¶

func CreateRenewDesktopsRequest() (request *RenewDesktopsRequest)

CreateRenewDesktopsRequest creates a request to invoke RenewDesktops API

type RenewDesktopsResponse ¶

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

RenewDesktopsResponse is the response struct for api RenewDesktops

func CreateRenewDesktopsResponse ¶

func CreateRenewDesktopsResponse() (response *RenewDesktopsResponse)

CreateRenewDesktopsResponse creates a response to parse from RenewDesktops response

type RenewNetworkPackagesRequest ¶

type RenewNetworkPackagesRequest struct {
	*requests.RpcRequest
	Period           requests.Integer `position:"Query" name:"Period"`
	AutoPay          requests.Boolean `position:"Query" name:"AutoPay"`
	NetworkPackageId *[]string        `position:"Query" name:"NetworkPackageId"  type:"Repeated"`
	PromotionId      string           `position:"Query" name:"PromotionId"`
	PeriodUnit       string           `position:"Query" name:"PeriodUnit"`
}

RenewNetworkPackagesRequest is the request struct for api RenewNetworkPackages

func CreateRenewNetworkPackagesRequest ¶

func CreateRenewNetworkPackagesRequest() (request *RenewNetworkPackagesRequest)

CreateRenewNetworkPackagesRequest creates a request to invoke RenewNetworkPackages API

type RenewNetworkPackagesResponse ¶

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

RenewNetworkPackagesResponse is the response struct for api RenewNetworkPackages

func CreateRenewNetworkPackagesResponse ¶

func CreateRenewNetworkPackagesResponse() (response *RenewNetworkPackagesResponse)

CreateRenewNetworkPackagesResponse creates a response to parse from RenewNetworkPackages response

type ResetDesktopsRequest ¶

type ResetDesktopsRequest struct {
	*requests.RpcRequest
	ImageId        string    `position:"Query" name:"ImageId"`
	ResetType      string    `position:"Query" name:"ResetType"`
	DesktopGroupId string    `position:"Query" name:"DesktopGroupId"`
	DesktopId      *[]string `position:"Query" name:"DesktopId"  type:"Repeated"`
	PayType        string    `position:"Query" name:"PayType"`
}

ResetDesktopsRequest is the request struct for api ResetDesktops

func CreateResetDesktopsRequest ¶

func CreateResetDesktopsRequest() (request *ResetDesktopsRequest)

CreateResetDesktopsRequest creates a request to invoke ResetDesktops API

type ResetDesktopsResponse ¶

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

ResetDesktopsResponse is the response struct for api ResetDesktops

func CreateResetDesktopsResponse ¶

func CreateResetDesktopsResponse() (response *ResetDesktopsResponse)

CreateResetDesktopsResponse creates a response to parse from ResetDesktops response

type ResetNASDefaultMountTargetRequest ¶

type ResetNASDefaultMountTargetRequest struct {
	*requests.RpcRequest
	FileSystemId string `position:"Query" name:"FileSystemId"`
}

ResetNASDefaultMountTargetRequest is the request struct for api ResetNASDefaultMountTarget

func CreateResetNASDefaultMountTargetRequest ¶

func CreateResetNASDefaultMountTargetRequest() (request *ResetNASDefaultMountTargetRequest)

CreateResetNASDefaultMountTargetRequest creates a request to invoke ResetNASDefaultMountTarget API

type ResetNASDefaultMountTargetResponse ¶

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

ResetNASDefaultMountTargetResponse is the response struct for api ResetNASDefaultMountTarget

func CreateResetNASDefaultMountTargetResponse ¶

func CreateResetNASDefaultMountTargetResponse() (response *ResetNASDefaultMountTargetResponse)

CreateResetNASDefaultMountTargetResponse creates a response to parse from ResetNASDefaultMountTarget response

type ResetSnapshotRequest ¶

type ResetSnapshotRequest struct {
	*requests.RpcRequest
	SnapshotId string `position:"Query" name:"SnapshotId"`
}

ResetSnapshotRequest is the request struct for api ResetSnapshot

func CreateResetSnapshotRequest ¶

func CreateResetSnapshotRequest() (request *ResetSnapshotRequest)

CreateResetSnapshotRequest creates a request to invoke ResetSnapshot API

type ResetSnapshotResponse ¶

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

ResetSnapshotResponse is the response struct for api ResetSnapshot

func CreateResetSnapshotResponse ¶

func CreateResetSnapshotResponse() (response *ResetSnapshotResponse)

CreateResetSnapshotResponse creates a response to parse from ResetSnapshot response

type RollbackSuspEventQuaraFileRequest ¶

type RollbackSuspEventQuaraFileRequest struct {
	*requests.RpcRequest
	QuaraFieldId requests.Integer `position:"Query" name:"QuaraFieldId"`
	DesktopId    string           `position:"Query" name:"DesktopId"`
}

RollbackSuspEventQuaraFileRequest is the request struct for api RollbackSuspEventQuaraFile

func CreateRollbackSuspEventQuaraFileRequest ¶

func CreateRollbackSuspEventQuaraFileRequest() (request *RollbackSuspEventQuaraFileRequest)

CreateRollbackSuspEventQuaraFileRequest creates a request to invoke RollbackSuspEventQuaraFile API

type RollbackSuspEventQuaraFileResponse ¶

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

RollbackSuspEventQuaraFileResponse is the response struct for api RollbackSuspEventQuaraFile

func CreateRollbackSuspEventQuaraFileResponse ¶

func CreateRollbackSuspEventQuaraFileResponse() (response *RollbackSuspEventQuaraFileResponse)

CreateRollbackSuspEventQuaraFileResponse creates a response to parse from RollbackSuspEventQuaraFile response

type RouteEntries ¶

type RouteEntries struct {
	RouteEntry []RouteEntry `json:"RouteEntry" xml:"RouteEntry"`
}

RouteEntries is a nested struct in ecd response

type RouteEntry ¶

type RouteEntry struct {
	Status               string `json:"Status" xml:"Status"`
	NextHopInstanceId    string `json:"NextHopInstanceId" xml:"NextHopInstanceId"`
	DestinationCidrBlock string `json:"DestinationCidrBlock" xml:"DestinationCidrBlock"`
	RegionId             string `json:"RegionId" xml:"RegionId"`
}

RouteEntry is a nested struct in ecd response

type RpmEntity ¶

type RpmEntity struct {
	Path        string `json:"Path" xml:"Path"`
	UpdateCmd   string `json:"UpdateCmd" xml:"UpdateCmd"`
	Name        string `json:"Name" xml:"Name"`
	FullVersion string `json:"FullVersion" xml:"FullVersion"`
	MatchDetail string `json:"MatchDetail" xml:"MatchDetail"`
}

RpmEntity is a nested struct in ecd response

type RpmEntityList ¶

type RpmEntityList struct {
	RpmEntity []RpmEntity `json:"RpmEntity" xml:"RpmEntity"`
}

RpmEntityList is a nested struct in ecd response

type RunCommandRequest ¶

type RunCommandRequest struct {
	*requests.RpcRequest
	Type            string           `position:"Query" name:"Type"`
	CommandContent  string           `position:"Query" name:"CommandContent"`
	Timeout         requests.Integer `position:"Query" name:"Timeout"`
	ContentEncoding string           `position:"Query" name:"ContentEncoding"`
	EndUserId       string           `position:"Query" name:"EndUserId"`
	DesktopId       *[]string        `position:"Query" name:"DesktopId"  type:"Repeated"`
}

RunCommandRequest is the request struct for api RunCommand

func CreateRunCommandRequest ¶

func CreateRunCommandRequest() (request *RunCommandRequest)

CreateRunCommandRequest creates a request to invoke RunCommand API

type RunCommandResponse ¶

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

RunCommandResponse is the response struct for api RunCommand

func CreateRunCommandResponse ¶

func CreateRunCommandResponse() (response *RunCommandResponse)

CreateRunCommandResponse creates a response to parse from RunCommand response

type SecurityEventOperation ¶

type SecurityEventOperation struct {
	OperationParams string `json:"OperationParams" xml:"OperationParams"`
	OperationCode   string `json:"OperationCode" xml:"OperationCode"`
	UserCanOperate  bool   `json:"UserCanOperate" xml:"UserCanOperate"`
}

SecurityEventOperation is a nested struct in ecd response

type SecurityEventOperationStatus ¶

type SecurityEventOperationStatus struct {
	Status          string `json:"Status" xml:"Status"`
	SecurityEventId int64  `json:"SecurityEventId" xml:"SecurityEventId"`
	ErrorCode       string `json:"ErrorCode" xml:"ErrorCode"`
}

SecurityEventOperationStatus is a nested struct in ecd response

type SecurityEventOperationStatuses ¶

type SecurityEventOperationStatuses struct {
	SecurityEventOperationStatus []SecurityEventOperationStatus `json:"SecurityEventOperationStatus" xml:"SecurityEventOperationStatus"`
}

SecurityEventOperationStatuses is a nested struct in ecd response

type SecurityEventOperations ¶

type SecurityEventOperations struct {
	SecurityEventOperation []SecurityEventOperation `json:"SecurityEventOperation" xml:"SecurityEventOperation"`
}

SecurityEventOperations is a nested struct in ecd response

type SendVerifyCodeRequest ¶

type SendVerifyCodeRequest struct {
	*requests.RpcRequest
	VerifyCodeAction string `position:"Query" name:"VerifyCodeAction"`
	ExtraInfo        string `position:"Query" name:"ExtraInfo"`
}

SendVerifyCodeRequest is the request struct for api SendVerifyCode

func CreateSendVerifyCodeRequest ¶

func CreateSendVerifyCodeRequest() (request *SendVerifyCodeRequest)

CreateSendVerifyCodeRequest creates a request to invoke SendVerifyCode API

type SendVerifyCodeResponse ¶

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

SendVerifyCodeResponse is the response struct for api SendVerifyCode

func CreateSendVerifyCodeResponse ¶

func CreateSendVerifyCodeResponse() (response *SendVerifyCodeResponse)

CreateSendVerifyCodeResponse creates a response to parse from SendVerifyCode response

type Session ¶

type Session struct {
	EndUserId         string `json:"EndUserId" xml:"EndUserId"`
	EstablishmentTime string `json:"EstablishmentTime" xml:"EstablishmentTime"`
	ExternalUserName  string `json:"ExternalUserName" xml:"ExternalUserName"`
}

Session is a nested struct in ecd response

type Sessions ¶

type Sessions struct {
	Session []Session `json:"Session" xml:"Session"`
}

Sessions is a nested struct in ecd response

type SetDirectorySsoStatusRequest ¶

type SetDirectorySsoStatusRequest struct {
	*requests.RpcRequest
	EnableSso   requests.Boolean `position:"Query" name:"EnableSso"`
	DirectoryId string           `position:"Query" name:"DirectoryId"`
}

SetDirectorySsoStatusRequest is the request struct for api SetDirectorySsoStatus

func CreateSetDirectorySsoStatusRequest ¶

func CreateSetDirectorySsoStatusRequest() (request *SetDirectorySsoStatusRequest)

CreateSetDirectorySsoStatusRequest creates a request to invoke SetDirectorySsoStatus API

type SetDirectorySsoStatusResponse ¶

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

SetDirectorySsoStatusResponse is the response struct for api SetDirectorySsoStatus

func CreateSetDirectorySsoStatusResponse ¶

func CreateSetDirectorySsoStatusResponse() (response *SetDirectorySsoStatusResponse)

CreateSetDirectorySsoStatusResponse creates a response to parse from SetDirectorySsoStatus response

type SetIdpMetadataRequest ¶

type SetIdpMetadataRequest struct {
	*requests.RpcRequest
	OfficeSiteId string `position:"Query" name:"OfficeSiteId"`
	DirectoryId  string `position:"Query" name:"DirectoryId"`
	IdpMetadata  string `position:"Query" name:"IdpMetadata"`
}

SetIdpMetadataRequest is the request struct for api SetIdpMetadata

func CreateSetIdpMetadataRequest ¶

func CreateSetIdpMetadataRequest() (request *SetIdpMetadataRequest)

CreateSetIdpMetadataRequest creates a request to invoke SetIdpMetadata API

type SetIdpMetadataResponse ¶

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

SetIdpMetadataResponse is the response struct for api SetIdpMetadata

func CreateSetIdpMetadataResponse ¶

func CreateSetIdpMetadataResponse() (response *SetIdpMetadataResponse)

CreateSetIdpMetadataResponse creates a response to parse from SetIdpMetadata response

type SetOfficeSiteSsoStatusRequest ¶

type SetOfficeSiteSsoStatusRequest struct {
	*requests.RpcRequest
	OfficeSiteId string           `position:"Query" name:"OfficeSiteId"`
	SsoType      string           `position:"Query" name:"SsoType"`
	EnableSso    requests.Boolean `position:"Query" name:"EnableSso"`
}

SetOfficeSiteSsoStatusRequest is the request struct for api SetOfficeSiteSsoStatus

func CreateSetOfficeSiteSsoStatusRequest ¶

func CreateSetOfficeSiteSsoStatusRequest() (request *SetOfficeSiteSsoStatusRequest)

CreateSetOfficeSiteSsoStatusRequest creates a request to invoke SetOfficeSiteSsoStatus API

type SetOfficeSiteSsoStatusResponse ¶

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

SetOfficeSiteSsoStatusResponse is the response struct for api SetOfficeSiteSsoStatus

func CreateSetOfficeSiteSsoStatusResponse ¶

func CreateSetOfficeSiteSsoStatusResponse() (response *SetOfficeSiteSsoStatusResponse)

CreateSetOfficeSiteSsoStatusResponse creates a response to parse from SetOfficeSiteSsoStatus response

type Snapshot ¶

type Snapshot struct {
	CreationTime            string `json:"CreationTime" xml:"CreationTime"`
	Status                  string `json:"Status" xml:"Status"`
	SnapshotType            string `json:"SnapshotType" xml:"SnapshotType"`
	SnapshotName            string `json:"SnapshotName" xml:"SnapshotName"`
	Progress                string `json:"Progress" xml:"Progress"`
	Description             string `json:"Description" xml:"Description"`
	SnapshotId              string `json:"SnapshotId" xml:"SnapshotId"`
	RemainTime              int    `json:"RemainTime" xml:"RemainTime"`
	SourceDiskSize          string `json:"SourceDiskSize" xml:"SourceDiskSize"`
	SourceDiskType          string `json:"SourceDiskType" xml:"SourceDiskType"`
	DesktopId               string `json:"DesktopId" xml:"DesktopId"`
	VolumeEncryptionEnabled bool   `json:"VolumeEncryptionEnabled" xml:"VolumeEncryptionEnabled"`
	VolumeEncryptionKey     string `json:"VolumeEncryptionKey" xml:"VolumeEncryptionKey"`
}

Snapshot is a nested struct in ecd response

type Snapshots ¶

type Snapshots struct {
	Snapshot []Snapshot `json:"Snapshot" xml:"Snapshot"`
}

Snapshots is a nested struct in ecd response

type StartDesktopsRequest ¶

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

StartDesktopsRequest is the request struct for api StartDesktops

func CreateStartDesktopsRequest ¶

func CreateStartDesktopsRequest() (request *StartDesktopsRequest)

CreateStartDesktopsRequest creates a request to invoke StartDesktops API

type StartDesktopsResponse ¶

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

StartDesktopsResponse is the response struct for api StartDesktops

func CreateStartDesktopsResponse ¶

func CreateStartDesktopsResponse() (response *StartDesktopsResponse)

CreateStartDesktopsResponse creates a response to parse from StartDesktops response

type StartVirusScanTaskRequest ¶

type StartVirusScanTaskRequest struct {
	*requests.RpcRequest
	OfficeSiteId *[]string `position:"Query" name:"OfficeSiteId"  type:"Repeated"`
	DesktopId    *[]string `position:"Query" name:"DesktopId"  type:"Repeated"`
}

StartVirusScanTaskRequest is the request struct for api StartVirusScanTask

func CreateStartVirusScanTaskRequest ¶

func CreateStartVirusScanTaskRequest() (request *StartVirusScanTaskRequest)

CreateStartVirusScanTaskRequest creates a request to invoke StartVirusScanTask API

type StartVirusScanTaskResponse ¶

type StartVirusScanTaskResponse struct {
	*responses.BaseResponse
	ScanTaskId int64  `json:"ScanTaskId" xml:"ScanTaskId"`
	RequestId  string `json:"RequestId" xml:"RequestId"`
}

StartVirusScanTaskResponse is the response struct for api StartVirusScanTask

func CreateStartVirusScanTaskResponse ¶

func CreateStartVirusScanTaskResponse() (response *StartVirusScanTaskResponse)

CreateStartVirusScanTaskResponse creates a response to parse from StartVirusScanTask response

type StopDesktopsRequest ¶

type StopDesktopsRequest struct {
	*requests.RpcRequest
	StoppedMode string    `position:"Query" name:"StoppedMode"`
	DesktopId   *[]string `position:"Query" name:"DesktopId"  type:"Repeated"`
}

StopDesktopsRequest is the request struct for api StopDesktops

func CreateStopDesktopsRequest ¶

func CreateStopDesktopsRequest() (request *StopDesktopsRequest)

CreateStopDesktopsRequest creates a request to invoke StopDesktops API

type StopDesktopsResponse ¶

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

StopDesktopsResponse is the response struct for api StopDesktops

func CreateStopDesktopsResponse ¶

func CreateStopDesktopsResponse() (response *StopDesktopsResponse)

CreateStopDesktopsResponse creates a response to parse from StopDesktops response

type StopInvocationRequest ¶

type StopInvocationRequest struct {
	*requests.RpcRequest
	InvokeId  string    `position:"Query" name:"InvokeId"`
	DesktopId *[]string `position:"Query" name:"DesktopId"  type:"Repeated"`
}

StopInvocationRequest is the request struct for api StopInvocation

func CreateStopInvocationRequest ¶

func CreateStopInvocationRequest() (request *StopInvocationRequest)

CreateStopInvocationRequest creates a request to invoke StopInvocation API

type StopInvocationResponse ¶

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

StopInvocationResponse is the response struct for api StopInvocation

func CreateStopInvocationResponse ¶

func CreateStopInvocationResponse() (response *StopInvocationResponse)

CreateStopInvocationResponse creates a response to parse from StopInvocation response

type SubDnsAddressInDescribeDirectories ¶

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

SubDnsAddressInDescribeDirectories is a nested struct in ecd response

type SubDnsAddressInDescribeOfficeSites ¶

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

SubDnsAddressInDescribeOfficeSites is a nested struct in ecd response

type SupportedLanguages ¶

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

SupportedLanguages is a nested struct in ecd response

type SuspEvent ¶

type SuspEvent struct {
	DataSource            string   `json:"DataSource" xml:"DataSource"`
	EventSubType          string   `json:"EventSubType" xml:"EventSubType"`
	DesktopName           string   `json:"DesktopName" xml:"DesktopName"`
	DesktopId             string   `json:"DesktopId" xml:"DesktopId"`
	OccurrenceTime        string   `json:"OccurrenceTime" xml:"OccurrenceTime"`
	AlarmEventTypeDisplay string   `json:"AlarmEventTypeDisplay" xml:"AlarmEventTypeDisplay"`
	AlarmUniqueInfo       string   `json:"AlarmUniqueInfo" xml:"AlarmUniqueInfo"`
	Desc                  string   `json:"Desc" xml:"Desc"`
	AlarmEventNameDisplay string   `json:"AlarmEventNameDisplay" xml:"AlarmEventNameDisplay"`
	CanCancelFault        bool     `json:"CanCancelFault" xml:"CanCancelFault"`
	LastTime              string   `json:"LastTime" xml:"LastTime"`
	OperateMsg            string   `json:"OperateMsg" xml:"OperateMsg"`
	CanBeDealOnLine       string   `json:"CanBeDealOnLine" xml:"CanBeDealOnLine"`
	AlarmEventType        string   `json:"AlarmEventType" xml:"AlarmEventType"`
	EventStatus           int      `json:"EventStatus" xml:"EventStatus"`
	OperateErrorCode      string   `json:"OperateErrorCode" xml:"OperateErrorCode"`
	AlarmEventName        string   `json:"AlarmEventName" xml:"AlarmEventName"`
	Name                  string   `json:"Name" xml:"Name"`
	UniqueInfo            string   `json:"UniqueInfo" xml:"UniqueInfo"`
	Level                 string   `json:"Level" xml:"Level"`
	Id                    int64    `json:"Id" xml:"Id"`
	Details               []Detail `json:"Details" xml:"Details"`
}

SuspEvent is a nested struct in ecd response

type SuspEvents ¶

type SuspEvents struct {
	SuspEvent []SuspEvent `json:"SuspEvent" xml:"SuspEvent"`
}

SuspEvents is a nested struct in ecd response

type Tag ¶

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

Tag is a nested struct in ecd response

type TagResource ¶

type TagResource struct {
	TagValue     string `json:"TagValue" xml:"TagValue"`
	ResourceType string `json:"ResourceType" xml:"ResourceType"`
	ResourceId   string `json:"ResourceId" xml:"ResourceId"`
	TagKey       string `json:"TagKey" xml:"TagKey"`
}

TagResource is a nested struct in ecd response

type TagResources ¶

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

TagResources is a nested struct in ecd response

type TagResourcesRequest ¶

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

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"`
}

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 {
	Value string `name:"Value"`
	Key   string `name:"Key"`
}

TagResourcesTag is a repeated param struct in TagResourcesRequest

type TagsInDescribeCens ¶

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

TagsInDescribeCens is a nested struct in ecd response

type TagsInDescribeDesktops ¶

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

TagsInDescribeDesktops is a nested struct in ecd response

type TimerInfo ¶

type TimerInfo struct {
	Status         int    `json:"Status" xml:"Status"`
	CronExpression string `json:"CronExpression" xml:"CronExpression"`
	TimerType      int    `json:"TimerType" xml:"TimerType"`
}

TimerInfo is a nested struct in ecd response

type TimerInfos ¶

type TimerInfos struct {
	TimerInfo []TimerInfo `json:"TimerInfo" xml:"TimerInfo"`
}

TimerInfos is a nested struct in ecd response

type UnlockVirtualMFADeviceRequest ¶

type UnlockVirtualMFADeviceRequest struct {
	*requests.RpcRequest
	SerialNumber string `position:"Query" name:"SerialNumber"`
}

UnlockVirtualMFADeviceRequest is the request struct for api UnlockVirtualMFADevice

func CreateUnlockVirtualMFADeviceRequest ¶

func CreateUnlockVirtualMFADeviceRequest() (request *UnlockVirtualMFADeviceRequest)

CreateUnlockVirtualMFADeviceRequest creates a request to invoke UnlockVirtualMFADevice API

type UnlockVirtualMFADeviceResponse ¶

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

UnlockVirtualMFADeviceResponse is the response struct for api UnlockVirtualMFADevice

func CreateUnlockVirtualMFADeviceResponse ¶

func CreateUnlockVirtualMFADeviceResponse() (response *UnlockVirtualMFADeviceResponse)

CreateUnlockVirtualMFADeviceResponse creates a response to parse from UnlockVirtualMFADevice response

type UntagResourcesRequest ¶

type UntagResourcesRequest struct {
	*requests.RpcRequest
	All          requests.Boolean `position:"Query" name:"All"`
	ResourceId   *[]string        `position:"Query" name:"ResourceId"  type:"Repeated"`
	ResourceType string           `position:"Query" name:"ResourceType"`
	TagKey       *[]string        `position:"Query" 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"`
}

UntagResourcesResponse is the response struct for api UntagResources

func CreateUntagResourcesResponse ¶

func CreateUntagResourcesResponse() (response *UntagResourcesResponse)

CreateUntagResourcesResponse creates a response to parse from UntagResources response

type UpdateFotaTaskRequest ¶

type UpdateFotaTaskRequest struct {
	*requests.RpcRequest
	UserStatus string `position:"Query" name:"UserStatus"`
	TaskUid    string `position:"Query" name:"TaskUid"`
}

UpdateFotaTaskRequest is the request struct for api UpdateFotaTask

func CreateUpdateFotaTaskRequest ¶

func CreateUpdateFotaTaskRequest() (request *UpdateFotaTaskRequest)

CreateUpdateFotaTaskRequest creates a request to invoke UpdateFotaTask API

type UpdateFotaTaskResponse ¶

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

UpdateFotaTaskResponse is the response struct for api UpdateFotaTask

func CreateUpdateFotaTaskResponse ¶

func CreateUpdateFotaTaskResponse() (response *UpdateFotaTaskResponse)

CreateUpdateFotaTaskResponse creates a response to parse from UpdateFotaTask response

type UploadImageRequest ¶

type UploadImageRequest struct {
	*requests.RpcRequest
	EnableSecurityCheck requests.Boolean `position:"Query" name:"EnableSecurityCheck"`
	GpuCategory         requests.Boolean `position:"Query" name:"GpuCategory"`
	Description         string           `position:"Query" name:"Description"`
	OssObjectPath       string           `position:"Query" name:"OssObjectPath"`
	ImageName           string           `position:"Query" name:"ImageName"`
	LicenseType         string           `position:"Query" name:"LicenseType"`
	OsType              string           `position:"Query" name:"OsType"`
	DataDiskSize        requests.Integer `position:"Query" name:"DataDiskSize"`
	ProtocolType        string           `position:"Query" name:"ProtocolType"`
	GpuDriverType       string           `position:"Query" name:"GpuDriverType"`
}

UploadImageRequest is the request struct for api UploadImage

func CreateUploadImageRequest ¶

func CreateUploadImageRequest() (request *UploadImageRequest)

CreateUploadImageRequest creates a request to invoke UploadImage API

type UploadImageResponse ¶

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

UploadImageResponse is the response struct for api UploadImage

func CreateUploadImageResponse ¶

func CreateUploadImageResponse() (response *UploadImageResponse)

CreateUploadImageResponse creates a response to parse from UploadImage response

type UsbSupplyRedirectRule ¶

type UsbSupplyRedirectRule struct {
	UsbSupplyRedirectRuleItem []UsbSupplyRedirectRuleItem `json:"UsbSupplyRedirectRule" xml:"UsbSupplyRedirectRule"`
}

UsbSupplyRedirectRule is a nested struct in ecd response

type UsbSupplyRedirectRuleItem ¶

type UsbSupplyRedirectRuleItem struct {
	VendorId        string `json:"VendorId" xml:"VendorId"`
	ProductId       string `json:"ProductId" xml:"ProductId"`
	Description     string `json:"Description" xml:"Description"`
	UsbRedirectType int64  `json:"UsbRedirectType" xml:"UsbRedirectType"`
	DeviceClass     string `json:"DeviceClass" xml:"DeviceClass"`
	DeviceSubclass  string `json:"DeviceSubclass" xml:"DeviceSubclass"`
	UsbRuleType     int64  `json:"UsbRuleType" xml:"UsbRuleType"`
}

UsbSupplyRedirectRuleItem is a nested struct in ecd response

type User ¶

type User struct {
	EndUser     string `json:"EndUser" xml:"EndUser"`
	DisplayName string `json:"DisplayName" xml:"DisplayName"`
}

User is a nested struct in ecd response

type UserSetPropertiesModels ¶

type UserSetPropertiesModels struct {
	PropertyId     int64            `json:"PropertyId" xml:"PropertyId"`
	UserName       string           `json:"UserName" xml:"UserName"`
	PropertyKey    string           `json:"PropertyKey" xml:"PropertyKey"`
	UserId         int64            `json:"UserId" xml:"UserId"`
	PropertyType   int              `json:"PropertyType" xml:"PropertyType"`
	PropertyValues []PropertyValues `json:"PropertyValues" xml:"PropertyValues"`
}

UserSetPropertiesModels is a nested struct in ecd response

type UserSetPropertiesModelsInDescribeUsersInGroup ¶

type UserSetPropertiesModelsInDescribeUsersInGroup struct {
	UserSetPropertiesModels []UserSetPropertiesModels `json:"userSetPropertiesModels" xml:"userSetPropertiesModels"`
}

UserSetPropertiesModelsInDescribeUsersInGroup is a nested struct in ecd response

type UsersInListDirectoryUsers ¶

type UsersInListDirectoryUsers struct {
	User []User `json:"User" xml:"User"`
}

UsersInListDirectoryUsers is a nested struct in ecd response

type UsersInListOfficeSiteUsers ¶

type UsersInListOfficeSiteUsers struct {
	User []User `json:"User" xml:"User"`
}

UsersInListOfficeSiteUsers is a nested struct in ecd response

type VSwitchIdsInDescribeDirectories ¶

type VSwitchIdsInDescribeDirectories struct {
	VSwitchId []string `json:"vSwitchId" xml:"vSwitchId"`
}

VSwitchIdsInDescribeDirectories is a nested struct in ecd response

type VSwitchIdsInDescribeOfficeSites ¶

type VSwitchIdsInDescribeOfficeSites struct {
	VSwitchId []string `json:"vSwitchId" xml:"vSwitchId"`
}

VSwitchIdsInDescribeOfficeSites is a nested struct in ecd response

type VerifyCenRequest ¶

type VerifyCenRequest struct {
	*requests.RpcRequest
	CenId      string           `position:"Query" name:"CenId"`
	CenOwnerId requests.Integer `position:"Query" name:"CenOwnerId"`
	VerifyCode string           `position:"Query" name:"VerifyCode"`
	CidrBlock  string           `position:"Query" name:"CidrBlock"`
}

VerifyCenRequest is the request struct for api VerifyCen

func CreateVerifyCenRequest ¶

func CreateVerifyCenRequest() (request *VerifyCenRequest)

CreateVerifyCenRequest creates a request to invoke VerifyCen API

type VerifyCenResponse ¶

type VerifyCenResponse struct {
	*responses.BaseResponse
	Status       string       `json:"Status" xml:"Status"`
	RequestId    string       `json:"RequestId" xml:"RequestId"`
	CidrBlocks   []string     `json:"CidrBlocks" xml:"CidrBlocks"`
	RouteEntries []RouteEntry `json:"RouteEntries" xml:"RouteEntries"`
}

VerifyCenResponse is the response struct for api VerifyCen

func CreateVerifyCenResponse ¶

func CreateVerifyCenResponse() (response *VerifyCenResponse)

CreateVerifyCenResponse creates a response to parse from VerifyCen response

type VirtualMFADevice ¶

type VirtualMFADevice struct {
	SerialNumber     string `json:"SerialNumber" xml:"SerialNumber"`
	GmtUnlock        string `json:"GmtUnlock" xml:"GmtUnlock"`
	EndUserId        string `json:"EndUserId" xml:"EndUserId"`
	ConsecutiveFails int    `json:"ConsecutiveFails" xml:"ConsecutiveFails"`
	OfficeSiteId     string `json:"OfficeSiteId" xml:"OfficeSiteId"`
	Status           string `json:"status" xml:"status"`
	DirectoryId      string `json:"DirectoryId" xml:"DirectoryId"`
	GmtEnabled       string `json:"GmtEnabled" xml:"GmtEnabled"`
}

VirtualMFADevice is a nested struct in ecd response

type VirtualMFADevices ¶

type VirtualMFADevices struct {
	VirtualMFADevice []VirtualMFADevice `json:"VirtualMFADevice" xml:"VirtualMFADevice"`
}

VirtualMFADevices is a nested struct in ecd response

type VulRecord ¶

type VulRecord struct {
	Status            int               `json:"Status" xml:"Status"`
	Type              string            `json:"Type" xml:"Type"`
	ModifyTs          int64             `json:"ModifyTs" xml:"ModifyTs"`
	DesktopName       string            `json:"DesktopName" xml:"DesktopName"`
	ResultCode        string            `json:"ResultCode" xml:"ResultCode"`
	Tag               string            `json:"Tag" xml:"Tag"`
	DesktopId         string            `json:"DesktopId" xml:"DesktopId"`
	Related           string            `json:"Related" xml:"Related"`
	LastTs            int64             `json:"LastTs" xml:"LastTs"`
	FirstTs           int64             `json:"FirstTs" xml:"FirstTs"`
	Necessity         string            `json:"Necessity" xml:"Necessity"`
	RepairTs          int64             `json:"RepairTs" xml:"RepairTs"`
	Online            bool              `json:"Online" xml:"Online"`
	ResultMessage     string            `json:"ResultMessage" xml:"ResultMessage"`
	OsVersion         string            `json:"OsVersion" xml:"OsVersion"`
	AliasName         string            `json:"AliasName" xml:"AliasName"`
	Name              string            `json:"Name" xml:"Name"`
	Progress          int               `json:"Progress" xml:"Progress"`
	DesktopGroupId    string            `json:"DesktopGroupId" xml:"DesktopGroupId"`
	ExtendContentJson ExtendContentJson `json:"ExtendContentJson" xml:"ExtendContentJson"`
}

VulRecord is a nested struct in ecd response

type VulRecords ¶

type VulRecords struct {
	VulRecord []VulRecord `json:"VulRecord" xml:"VulRecord"`
}

VulRecords is a nested struct in ecd response

type Zone ¶

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

Zone is a nested struct in ecd response

type Zones ¶

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

Zones is a nested struct in ecd response

Source Files ¶

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL