@alicloud/ecd20201002 1.0.0 → 2.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +13 -0
- package/README.md +25 -0
- package/dist/client.d.ts +1608 -93
- package/dist/client.js +3570 -176
- package/dist/client.js.map +1 -1
- package/package.json +6 -5
- package/src/client.ts +4480 -247
package/dist/client.d.ts
CHANGED
|
@@ -1,12 +1,1101 @@
|
|
|
1
|
+
/**
|
|
2
|
+
*
|
|
3
|
+
*/
|
|
1
4
|
import * as $Util from '@alicloud/tea-util';
|
|
2
|
-
import
|
|
5
|
+
import OpenApi, * as $OpenApi from '@alicloud/openapi-client';
|
|
3
6
|
import * as $tea from '@alicloud/tea-typescript';
|
|
7
|
+
export declare class ApproveFotaUpdateRequest extends $tea.Model {
|
|
8
|
+
appVersion?: string;
|
|
9
|
+
clientId?: string;
|
|
10
|
+
desktopId?: string;
|
|
11
|
+
loginToken?: string;
|
|
12
|
+
regionId?: string;
|
|
13
|
+
sessionId?: string;
|
|
14
|
+
uuid?: string;
|
|
15
|
+
static names(): {
|
|
16
|
+
[key: string]: string;
|
|
17
|
+
};
|
|
18
|
+
static types(): {
|
|
19
|
+
[key: string]: any;
|
|
20
|
+
};
|
|
21
|
+
constructor(map?: {
|
|
22
|
+
[key: string]: any;
|
|
23
|
+
});
|
|
24
|
+
}
|
|
25
|
+
export declare class ApproveFotaUpdateResponseBody extends $tea.Model {
|
|
26
|
+
requestId?: string;
|
|
27
|
+
static names(): {
|
|
28
|
+
[key: string]: string;
|
|
29
|
+
};
|
|
30
|
+
static types(): {
|
|
31
|
+
[key: string]: any;
|
|
32
|
+
};
|
|
33
|
+
constructor(map?: {
|
|
34
|
+
[key: string]: any;
|
|
35
|
+
});
|
|
36
|
+
}
|
|
37
|
+
export declare class ApproveFotaUpdateResponse extends $tea.Model {
|
|
38
|
+
headers?: {
|
|
39
|
+
[key: string]: string;
|
|
40
|
+
};
|
|
41
|
+
statusCode?: number;
|
|
42
|
+
body?: ApproveFotaUpdateResponseBody;
|
|
43
|
+
static names(): {
|
|
44
|
+
[key: string]: string;
|
|
45
|
+
};
|
|
46
|
+
static types(): {
|
|
47
|
+
[key: string]: any;
|
|
48
|
+
};
|
|
49
|
+
constructor(map?: {
|
|
50
|
+
[key: string]: any;
|
|
51
|
+
});
|
|
52
|
+
}
|
|
53
|
+
export declare class ChangePasswordRequest extends $tea.Model {
|
|
54
|
+
clientId?: string;
|
|
55
|
+
endUserId?: string;
|
|
56
|
+
loginToken?: string;
|
|
57
|
+
newPassword?: string;
|
|
58
|
+
officeSiteId?: string;
|
|
59
|
+
oldPassword?: string;
|
|
60
|
+
regionId?: string;
|
|
61
|
+
sessionId?: string;
|
|
62
|
+
static names(): {
|
|
63
|
+
[key: string]: string;
|
|
64
|
+
};
|
|
65
|
+
static types(): {
|
|
66
|
+
[key: string]: any;
|
|
67
|
+
};
|
|
68
|
+
constructor(map?: {
|
|
69
|
+
[key: string]: any;
|
|
70
|
+
});
|
|
71
|
+
}
|
|
72
|
+
export declare class ChangePasswordResponseBody extends $tea.Model {
|
|
73
|
+
loginToken?: string;
|
|
74
|
+
requestId?: string;
|
|
75
|
+
static names(): {
|
|
76
|
+
[key: string]: string;
|
|
77
|
+
};
|
|
78
|
+
static types(): {
|
|
79
|
+
[key: string]: any;
|
|
80
|
+
};
|
|
81
|
+
constructor(map?: {
|
|
82
|
+
[key: string]: any;
|
|
83
|
+
});
|
|
84
|
+
}
|
|
85
|
+
export declare class ChangePasswordResponse extends $tea.Model {
|
|
86
|
+
headers?: {
|
|
87
|
+
[key: string]: string;
|
|
88
|
+
};
|
|
89
|
+
statusCode?: number;
|
|
90
|
+
body?: ChangePasswordResponseBody;
|
|
91
|
+
static names(): {
|
|
92
|
+
[key: string]: string;
|
|
93
|
+
};
|
|
94
|
+
static types(): {
|
|
95
|
+
[key: string]: any;
|
|
96
|
+
};
|
|
97
|
+
constructor(map?: {
|
|
98
|
+
[key: string]: any;
|
|
99
|
+
});
|
|
100
|
+
}
|
|
101
|
+
export declare class DeleteFingerPrintTemplateRequest extends $tea.Model {
|
|
102
|
+
clientId?: string;
|
|
103
|
+
clientToken?: string;
|
|
104
|
+
index?: number;
|
|
105
|
+
loginToken?: string;
|
|
106
|
+
regionId?: string;
|
|
107
|
+
sessionId?: string;
|
|
108
|
+
static names(): {
|
|
109
|
+
[key: string]: string;
|
|
110
|
+
};
|
|
111
|
+
static types(): {
|
|
112
|
+
[key: string]: any;
|
|
113
|
+
};
|
|
114
|
+
constructor(map?: {
|
|
115
|
+
[key: string]: any;
|
|
116
|
+
});
|
|
117
|
+
}
|
|
118
|
+
export declare class DeleteFingerPrintTemplateResponseBody extends $tea.Model {
|
|
119
|
+
requestId?: string;
|
|
120
|
+
static names(): {
|
|
121
|
+
[key: string]: string;
|
|
122
|
+
};
|
|
123
|
+
static types(): {
|
|
124
|
+
[key: string]: any;
|
|
125
|
+
};
|
|
126
|
+
constructor(map?: {
|
|
127
|
+
[key: string]: any;
|
|
128
|
+
});
|
|
129
|
+
}
|
|
130
|
+
export declare class DeleteFingerPrintTemplateResponse extends $tea.Model {
|
|
131
|
+
headers?: {
|
|
132
|
+
[key: string]: string;
|
|
133
|
+
};
|
|
134
|
+
statusCode?: number;
|
|
135
|
+
body?: DeleteFingerPrintTemplateResponseBody;
|
|
136
|
+
static names(): {
|
|
137
|
+
[key: string]: string;
|
|
138
|
+
};
|
|
139
|
+
static types(): {
|
|
140
|
+
[key: string]: any;
|
|
141
|
+
};
|
|
142
|
+
constructor(map?: {
|
|
143
|
+
[key: string]: any;
|
|
144
|
+
});
|
|
145
|
+
}
|
|
146
|
+
export declare class DescribeDirectoriesRequest extends $tea.Model {
|
|
147
|
+
clientId?: string;
|
|
148
|
+
directoryId?: string[];
|
|
149
|
+
regionId?: string;
|
|
150
|
+
static names(): {
|
|
151
|
+
[key: string]: string;
|
|
152
|
+
};
|
|
153
|
+
static types(): {
|
|
154
|
+
[key: string]: any;
|
|
155
|
+
};
|
|
156
|
+
constructor(map?: {
|
|
157
|
+
[key: string]: any;
|
|
158
|
+
});
|
|
159
|
+
}
|
|
160
|
+
export declare class DescribeDirectoriesResponseBody extends $tea.Model {
|
|
161
|
+
directories?: DescribeDirectoriesResponseBodyDirectories[];
|
|
162
|
+
requestId?: string;
|
|
163
|
+
static names(): {
|
|
164
|
+
[key: string]: string;
|
|
165
|
+
};
|
|
166
|
+
static types(): {
|
|
167
|
+
[key: string]: any;
|
|
168
|
+
};
|
|
169
|
+
constructor(map?: {
|
|
170
|
+
[key: string]: any;
|
|
171
|
+
});
|
|
172
|
+
}
|
|
173
|
+
export declare class DescribeDirectoriesResponse extends $tea.Model {
|
|
174
|
+
headers?: {
|
|
175
|
+
[key: string]: string;
|
|
176
|
+
};
|
|
177
|
+
statusCode?: number;
|
|
178
|
+
body?: DescribeDirectoriesResponseBody;
|
|
179
|
+
static names(): {
|
|
180
|
+
[key: string]: string;
|
|
181
|
+
};
|
|
182
|
+
static types(): {
|
|
183
|
+
[key: string]: any;
|
|
184
|
+
};
|
|
185
|
+
constructor(map?: {
|
|
186
|
+
[key: string]: any;
|
|
187
|
+
});
|
|
188
|
+
}
|
|
189
|
+
export declare class DescribeFingerPrintTemplatesRequest extends $tea.Model {
|
|
190
|
+
clientId?: string;
|
|
191
|
+
loginToken?: string;
|
|
192
|
+
regionId?: string;
|
|
193
|
+
sessionId?: string;
|
|
194
|
+
static names(): {
|
|
195
|
+
[key: string]: string;
|
|
196
|
+
};
|
|
197
|
+
static types(): {
|
|
198
|
+
[key: string]: any;
|
|
199
|
+
};
|
|
200
|
+
constructor(map?: {
|
|
201
|
+
[key: string]: any;
|
|
202
|
+
});
|
|
203
|
+
}
|
|
204
|
+
export declare class DescribeFingerPrintTemplatesResponseBody extends $tea.Model {
|
|
205
|
+
fingerPrintTemplates?: DescribeFingerPrintTemplatesResponseBodyFingerPrintTemplates[];
|
|
206
|
+
requestId?: string;
|
|
207
|
+
static names(): {
|
|
208
|
+
[key: string]: string;
|
|
209
|
+
};
|
|
210
|
+
static types(): {
|
|
211
|
+
[key: string]: any;
|
|
212
|
+
};
|
|
213
|
+
constructor(map?: {
|
|
214
|
+
[key: string]: any;
|
|
215
|
+
});
|
|
216
|
+
}
|
|
217
|
+
export declare class DescribeFingerPrintTemplatesResponse extends $tea.Model {
|
|
218
|
+
headers?: {
|
|
219
|
+
[key: string]: string;
|
|
220
|
+
};
|
|
221
|
+
statusCode?: number;
|
|
222
|
+
body?: DescribeFingerPrintTemplatesResponseBody;
|
|
223
|
+
static names(): {
|
|
224
|
+
[key: string]: string;
|
|
225
|
+
};
|
|
226
|
+
static types(): {
|
|
227
|
+
[key: string]: any;
|
|
228
|
+
};
|
|
229
|
+
constructor(map?: {
|
|
230
|
+
[key: string]: any;
|
|
231
|
+
});
|
|
232
|
+
}
|
|
233
|
+
export declare class DescribeGlobalDesktopsRequest extends $tea.Model {
|
|
234
|
+
clientId?: string;
|
|
235
|
+
desktopAccessType?: string;
|
|
236
|
+
desktopId?: string[];
|
|
237
|
+
desktopName?: string;
|
|
238
|
+
desktopStatus?: string;
|
|
239
|
+
directoryId?: string;
|
|
240
|
+
keyword?: string;
|
|
241
|
+
loginRegionId?: string;
|
|
242
|
+
loginToken?: string;
|
|
243
|
+
maxResults?: number;
|
|
244
|
+
nextToken?: string;
|
|
245
|
+
officeSiteId?: string;
|
|
246
|
+
orderBy?: string;
|
|
247
|
+
queryFotaUpdate?: boolean;
|
|
248
|
+
regionId?: string;
|
|
249
|
+
searchRegionId?: string;
|
|
250
|
+
sessionId?: string;
|
|
251
|
+
sortType?: string;
|
|
252
|
+
withoutLatency?: boolean;
|
|
253
|
+
static names(): {
|
|
254
|
+
[key: string]: string;
|
|
255
|
+
};
|
|
256
|
+
static types(): {
|
|
257
|
+
[key: string]: any;
|
|
258
|
+
};
|
|
259
|
+
constructor(map?: {
|
|
260
|
+
[key: string]: any;
|
|
261
|
+
});
|
|
262
|
+
}
|
|
263
|
+
export declare class DescribeGlobalDesktopsResponseBody extends $tea.Model {
|
|
264
|
+
desktops?: DescribeGlobalDesktopsResponseBodyDesktops[];
|
|
265
|
+
nextToken?: string;
|
|
266
|
+
requestId?: string;
|
|
267
|
+
static names(): {
|
|
268
|
+
[key: string]: string;
|
|
269
|
+
};
|
|
270
|
+
static types(): {
|
|
271
|
+
[key: string]: any;
|
|
272
|
+
};
|
|
273
|
+
constructor(map?: {
|
|
274
|
+
[key: string]: any;
|
|
275
|
+
});
|
|
276
|
+
}
|
|
277
|
+
export declare class DescribeGlobalDesktopsResponse extends $tea.Model {
|
|
278
|
+
headers?: {
|
|
279
|
+
[key: string]: string;
|
|
280
|
+
};
|
|
281
|
+
statusCode?: number;
|
|
282
|
+
body?: DescribeGlobalDesktopsResponseBody;
|
|
283
|
+
static names(): {
|
|
284
|
+
[key: string]: string;
|
|
285
|
+
};
|
|
286
|
+
static types(): {
|
|
287
|
+
[key: string]: any;
|
|
288
|
+
};
|
|
289
|
+
constructor(map?: {
|
|
290
|
+
[key: string]: any;
|
|
291
|
+
});
|
|
292
|
+
}
|
|
293
|
+
export declare class DescribeOfficeSitesRequest extends $tea.Model {
|
|
294
|
+
clientId?: string;
|
|
295
|
+
officeSiteId?: string[];
|
|
296
|
+
regionId?: string;
|
|
297
|
+
static names(): {
|
|
298
|
+
[key: string]: string;
|
|
299
|
+
};
|
|
300
|
+
static types(): {
|
|
301
|
+
[key: string]: any;
|
|
302
|
+
};
|
|
303
|
+
constructor(map?: {
|
|
304
|
+
[key: string]: any;
|
|
305
|
+
});
|
|
306
|
+
}
|
|
307
|
+
export declare class DescribeOfficeSitesResponseBody extends $tea.Model {
|
|
308
|
+
officeSites?: DescribeOfficeSitesResponseBodyOfficeSites[];
|
|
309
|
+
requestId?: string;
|
|
310
|
+
static names(): {
|
|
311
|
+
[key: string]: string;
|
|
312
|
+
};
|
|
313
|
+
static types(): {
|
|
314
|
+
[key: string]: any;
|
|
315
|
+
};
|
|
316
|
+
constructor(map?: {
|
|
317
|
+
[key: string]: any;
|
|
318
|
+
});
|
|
319
|
+
}
|
|
320
|
+
export declare class DescribeOfficeSitesResponse extends $tea.Model {
|
|
321
|
+
headers?: {
|
|
322
|
+
[key: string]: string;
|
|
323
|
+
};
|
|
324
|
+
statusCode?: number;
|
|
325
|
+
body?: DescribeOfficeSitesResponseBody;
|
|
326
|
+
static names(): {
|
|
327
|
+
[key: string]: string;
|
|
328
|
+
};
|
|
329
|
+
static types(): {
|
|
330
|
+
[key: string]: any;
|
|
331
|
+
};
|
|
332
|
+
constructor(map?: {
|
|
333
|
+
[key: string]: any;
|
|
334
|
+
});
|
|
335
|
+
}
|
|
336
|
+
export declare class DescribeRegionsRequest extends $tea.Model {
|
|
337
|
+
clientId?: string;
|
|
338
|
+
regionId?: string;
|
|
339
|
+
static names(): {
|
|
340
|
+
[key: string]: string;
|
|
341
|
+
};
|
|
342
|
+
static types(): {
|
|
343
|
+
[key: string]: any;
|
|
344
|
+
};
|
|
345
|
+
constructor(map?: {
|
|
346
|
+
[key: string]: any;
|
|
347
|
+
});
|
|
348
|
+
}
|
|
349
|
+
export declare class DescribeRegionsResponseBody extends $tea.Model {
|
|
350
|
+
regions?: DescribeRegionsResponseBodyRegions[];
|
|
351
|
+
requestId?: string;
|
|
352
|
+
static names(): {
|
|
353
|
+
[key: string]: string;
|
|
354
|
+
};
|
|
355
|
+
static types(): {
|
|
356
|
+
[key: string]: any;
|
|
357
|
+
};
|
|
358
|
+
constructor(map?: {
|
|
359
|
+
[key: string]: any;
|
|
360
|
+
});
|
|
361
|
+
}
|
|
362
|
+
export declare class DescribeRegionsResponse extends $tea.Model {
|
|
363
|
+
headers?: {
|
|
364
|
+
[key: string]: string;
|
|
365
|
+
};
|
|
366
|
+
statusCode?: number;
|
|
367
|
+
body?: DescribeRegionsResponseBody;
|
|
368
|
+
static names(): {
|
|
369
|
+
[key: string]: string;
|
|
370
|
+
};
|
|
371
|
+
static types(): {
|
|
372
|
+
[key: string]: any;
|
|
373
|
+
};
|
|
374
|
+
constructor(map?: {
|
|
375
|
+
[key: string]: any;
|
|
376
|
+
});
|
|
377
|
+
}
|
|
378
|
+
export declare class DescribeSnapshotsRequest extends $tea.Model {
|
|
379
|
+
clientId?: string;
|
|
380
|
+
desktopId?: string;
|
|
381
|
+
loginToken?: string;
|
|
382
|
+
maxResults?: number;
|
|
383
|
+
nextToken?: string;
|
|
384
|
+
regionId?: string;
|
|
385
|
+
sessionId?: string;
|
|
386
|
+
snapshotId?: string;
|
|
387
|
+
static names(): {
|
|
388
|
+
[key: string]: string;
|
|
389
|
+
};
|
|
390
|
+
static types(): {
|
|
391
|
+
[key: string]: any;
|
|
392
|
+
};
|
|
393
|
+
constructor(map?: {
|
|
394
|
+
[key: string]: any;
|
|
395
|
+
});
|
|
396
|
+
}
|
|
397
|
+
export declare class DescribeSnapshotsResponseBody extends $tea.Model {
|
|
398
|
+
nextToken?: string;
|
|
399
|
+
requestId?: string;
|
|
400
|
+
snapshots?: DescribeSnapshotsResponseBodySnapshots[];
|
|
401
|
+
static names(): {
|
|
402
|
+
[key: string]: string;
|
|
403
|
+
};
|
|
404
|
+
static types(): {
|
|
405
|
+
[key: string]: any;
|
|
406
|
+
};
|
|
407
|
+
constructor(map?: {
|
|
408
|
+
[key: string]: any;
|
|
409
|
+
});
|
|
410
|
+
}
|
|
411
|
+
export declare class DescribeSnapshotsResponse extends $tea.Model {
|
|
412
|
+
headers?: {
|
|
413
|
+
[key: string]: string;
|
|
414
|
+
};
|
|
415
|
+
statusCode?: number;
|
|
416
|
+
body?: DescribeSnapshotsResponseBody;
|
|
417
|
+
static names(): {
|
|
418
|
+
[key: string]: string;
|
|
419
|
+
};
|
|
420
|
+
static types(): {
|
|
421
|
+
[key: string]: any;
|
|
422
|
+
};
|
|
423
|
+
constructor(map?: {
|
|
424
|
+
[key: string]: any;
|
|
425
|
+
});
|
|
426
|
+
}
|
|
427
|
+
export declare class EncryptPasswordRequest extends $tea.Model {
|
|
428
|
+
clientId?: string;
|
|
429
|
+
directoryId?: string;
|
|
430
|
+
loginToken?: string;
|
|
431
|
+
officeSiteId?: string;
|
|
432
|
+
password?: string;
|
|
433
|
+
regionId?: string;
|
|
434
|
+
sessionId?: string;
|
|
435
|
+
static names(): {
|
|
436
|
+
[key: string]: string;
|
|
437
|
+
};
|
|
438
|
+
static types(): {
|
|
439
|
+
[key: string]: any;
|
|
440
|
+
};
|
|
441
|
+
constructor(map?: {
|
|
442
|
+
[key: string]: any;
|
|
443
|
+
});
|
|
444
|
+
}
|
|
445
|
+
export declare class EncryptPasswordResponseBody extends $tea.Model {
|
|
446
|
+
encryptedPassword?: string;
|
|
447
|
+
requestId?: string;
|
|
448
|
+
static names(): {
|
|
449
|
+
[key: string]: string;
|
|
450
|
+
};
|
|
451
|
+
static types(): {
|
|
452
|
+
[key: string]: any;
|
|
453
|
+
};
|
|
454
|
+
constructor(map?: {
|
|
455
|
+
[key: string]: any;
|
|
456
|
+
});
|
|
457
|
+
}
|
|
458
|
+
export declare class EncryptPasswordResponse extends $tea.Model {
|
|
459
|
+
headers?: {
|
|
460
|
+
[key: string]: string;
|
|
461
|
+
};
|
|
462
|
+
statusCode?: number;
|
|
463
|
+
body?: EncryptPasswordResponseBody;
|
|
464
|
+
static names(): {
|
|
465
|
+
[key: string]: string;
|
|
466
|
+
};
|
|
467
|
+
static types(): {
|
|
468
|
+
[key: string]: any;
|
|
469
|
+
};
|
|
470
|
+
constructor(map?: {
|
|
471
|
+
[key: string]: any;
|
|
472
|
+
});
|
|
473
|
+
}
|
|
474
|
+
export declare class GetCloudDriveServiceMountTokenRequest extends $tea.Model {
|
|
475
|
+
clientId?: string;
|
|
476
|
+
loginToken?: string;
|
|
477
|
+
officeSiteId?: string;
|
|
478
|
+
regionId?: string;
|
|
479
|
+
sessionId?: string;
|
|
480
|
+
static names(): {
|
|
481
|
+
[key: string]: string;
|
|
482
|
+
};
|
|
483
|
+
static types(): {
|
|
484
|
+
[key: string]: any;
|
|
485
|
+
};
|
|
486
|
+
constructor(map?: {
|
|
487
|
+
[key: string]: any;
|
|
488
|
+
});
|
|
489
|
+
}
|
|
490
|
+
export declare class GetCloudDriveServiceMountTokenResponseBody extends $tea.Model {
|
|
491
|
+
requestId?: string;
|
|
492
|
+
token?: GetCloudDriveServiceMountTokenResponseBodyToken;
|
|
493
|
+
static names(): {
|
|
494
|
+
[key: string]: string;
|
|
495
|
+
};
|
|
496
|
+
static types(): {
|
|
497
|
+
[key: string]: any;
|
|
498
|
+
};
|
|
499
|
+
constructor(map?: {
|
|
500
|
+
[key: string]: any;
|
|
501
|
+
});
|
|
502
|
+
}
|
|
503
|
+
export declare class GetCloudDriveServiceMountTokenResponse extends $tea.Model {
|
|
504
|
+
headers?: {
|
|
505
|
+
[key: string]: string;
|
|
506
|
+
};
|
|
507
|
+
statusCode?: number;
|
|
508
|
+
body?: GetCloudDriveServiceMountTokenResponseBody;
|
|
509
|
+
static names(): {
|
|
510
|
+
[key: string]: string;
|
|
511
|
+
};
|
|
512
|
+
static types(): {
|
|
513
|
+
[key: string]: any;
|
|
514
|
+
};
|
|
515
|
+
constructor(map?: {
|
|
516
|
+
[key: string]: any;
|
|
517
|
+
});
|
|
518
|
+
}
|
|
519
|
+
export declare class GetConnectionTicketRequest extends $tea.Model {
|
|
520
|
+
clientId?: string;
|
|
521
|
+
clientOS?: string;
|
|
522
|
+
clientType?: string;
|
|
523
|
+
clientVersion?: string;
|
|
524
|
+
commandContent?: string;
|
|
525
|
+
desktopId?: string;
|
|
526
|
+
loginToken?: string;
|
|
527
|
+
ownerId?: number;
|
|
528
|
+
regionId?: string;
|
|
529
|
+
resourceOwnerAccount?: string;
|
|
530
|
+
resourceOwnerId?: number;
|
|
531
|
+
sessionId?: string;
|
|
532
|
+
taskId?: string;
|
|
533
|
+
uuid?: string;
|
|
534
|
+
static names(): {
|
|
535
|
+
[key: string]: string;
|
|
536
|
+
};
|
|
537
|
+
static types(): {
|
|
538
|
+
[key: string]: any;
|
|
539
|
+
};
|
|
540
|
+
constructor(map?: {
|
|
541
|
+
[key: string]: any;
|
|
542
|
+
});
|
|
543
|
+
}
|
|
544
|
+
export declare class GetConnectionTicketResponseBody extends $tea.Model {
|
|
545
|
+
requestId?: string;
|
|
546
|
+
taskCode?: string;
|
|
547
|
+
taskId?: string;
|
|
548
|
+
taskMessage?: string;
|
|
549
|
+
taskStatus?: string;
|
|
550
|
+
ticket?: string;
|
|
551
|
+
static names(): {
|
|
552
|
+
[key: string]: string;
|
|
553
|
+
};
|
|
554
|
+
static types(): {
|
|
555
|
+
[key: string]: any;
|
|
556
|
+
};
|
|
557
|
+
constructor(map?: {
|
|
558
|
+
[key: string]: any;
|
|
559
|
+
});
|
|
560
|
+
}
|
|
561
|
+
export declare class GetConnectionTicketResponse extends $tea.Model {
|
|
562
|
+
headers?: {
|
|
563
|
+
[key: string]: string;
|
|
564
|
+
};
|
|
565
|
+
statusCode?: number;
|
|
566
|
+
body?: GetConnectionTicketResponseBody;
|
|
567
|
+
static names(): {
|
|
568
|
+
[key: string]: string;
|
|
569
|
+
};
|
|
570
|
+
static types(): {
|
|
571
|
+
[key: string]: any;
|
|
572
|
+
};
|
|
573
|
+
constructor(map?: {
|
|
574
|
+
[key: string]: any;
|
|
575
|
+
});
|
|
576
|
+
}
|
|
577
|
+
export declare class GetLoginTokenRequest extends $tea.Model {
|
|
578
|
+
authenticationCode?: string;
|
|
579
|
+
clientId?: string;
|
|
580
|
+
clientOS?: string;
|
|
581
|
+
clientType?: string;
|
|
582
|
+
clientVersion?: string;
|
|
583
|
+
currentStage?: string;
|
|
584
|
+
directoryId?: string;
|
|
585
|
+
endUserId?: string;
|
|
586
|
+
keepAlive?: boolean;
|
|
587
|
+
keepAliveToken?: string;
|
|
588
|
+
newPassword?: string;
|
|
589
|
+
officeSiteId?: string;
|
|
590
|
+
oldPassword?: string;
|
|
591
|
+
password?: string;
|
|
592
|
+
regionId?: string;
|
|
593
|
+
sessionId?: string;
|
|
594
|
+
tokenCode?: string;
|
|
595
|
+
uuid?: string;
|
|
596
|
+
static names(): {
|
|
597
|
+
[key: string]: string;
|
|
598
|
+
};
|
|
599
|
+
static types(): {
|
|
600
|
+
[key: string]: any;
|
|
601
|
+
};
|
|
602
|
+
constructor(map?: {
|
|
603
|
+
[key: string]: any;
|
|
604
|
+
});
|
|
605
|
+
}
|
|
606
|
+
export declare class GetLoginTokenResponseBody extends $tea.Model {
|
|
607
|
+
email?: string;
|
|
608
|
+
endUserId?: string;
|
|
609
|
+
industry?: string;
|
|
610
|
+
keepAliveToken?: string;
|
|
611
|
+
label?: string;
|
|
612
|
+
loginToken?: string;
|
|
613
|
+
nextStage?: string;
|
|
614
|
+
phone?: string;
|
|
615
|
+
props?: {
|
|
616
|
+
[key: string]: string;
|
|
617
|
+
};
|
|
618
|
+
qrCodePng?: string;
|
|
619
|
+
requestId?: string;
|
|
620
|
+
secret?: string;
|
|
621
|
+
sessionId?: string;
|
|
622
|
+
tenantId?: number;
|
|
623
|
+
windowDisplayMode?: string;
|
|
624
|
+
static names(): {
|
|
625
|
+
[key: string]: string;
|
|
626
|
+
};
|
|
627
|
+
static types(): {
|
|
628
|
+
[key: string]: any;
|
|
629
|
+
};
|
|
630
|
+
constructor(map?: {
|
|
631
|
+
[key: string]: any;
|
|
632
|
+
});
|
|
633
|
+
}
|
|
634
|
+
export declare class GetLoginTokenResponse extends $tea.Model {
|
|
635
|
+
headers?: {
|
|
636
|
+
[key: string]: string;
|
|
637
|
+
};
|
|
638
|
+
statusCode?: number;
|
|
639
|
+
body?: GetLoginTokenResponseBody;
|
|
640
|
+
static names(): {
|
|
641
|
+
[key: string]: string;
|
|
642
|
+
};
|
|
643
|
+
static types(): {
|
|
644
|
+
[key: string]: any;
|
|
645
|
+
};
|
|
646
|
+
constructor(map?: {
|
|
647
|
+
[key: string]: any;
|
|
648
|
+
});
|
|
649
|
+
}
|
|
650
|
+
export declare class IsKeepAliveRequest extends $tea.Model {
|
|
651
|
+
clientId?: string;
|
|
652
|
+
officeSiteId?: string;
|
|
653
|
+
regionId?: string;
|
|
654
|
+
static names(): {
|
|
655
|
+
[key: string]: string;
|
|
656
|
+
};
|
|
657
|
+
static types(): {
|
|
658
|
+
[key: string]: any;
|
|
659
|
+
};
|
|
660
|
+
constructor(map?: {
|
|
661
|
+
[key: string]: any;
|
|
662
|
+
});
|
|
663
|
+
}
|
|
664
|
+
export declare class IsKeepAliveResponseBody extends $tea.Model {
|
|
665
|
+
isKeepAlive?: boolean;
|
|
666
|
+
officeSiteId?: string;
|
|
667
|
+
requestId?: string;
|
|
668
|
+
tenantId?: string;
|
|
669
|
+
static names(): {
|
|
670
|
+
[key: string]: string;
|
|
671
|
+
};
|
|
672
|
+
static types(): {
|
|
673
|
+
[key: string]: any;
|
|
674
|
+
};
|
|
675
|
+
constructor(map?: {
|
|
676
|
+
[key: string]: any;
|
|
677
|
+
});
|
|
678
|
+
}
|
|
679
|
+
export declare class IsKeepAliveResponse extends $tea.Model {
|
|
680
|
+
headers?: {
|
|
681
|
+
[key: string]: string;
|
|
682
|
+
};
|
|
683
|
+
statusCode?: number;
|
|
684
|
+
body?: IsKeepAliveResponseBody;
|
|
685
|
+
static names(): {
|
|
686
|
+
[key: string]: string;
|
|
687
|
+
};
|
|
688
|
+
static types(): {
|
|
689
|
+
[key: string]: any;
|
|
690
|
+
};
|
|
691
|
+
constructor(map?: {
|
|
692
|
+
[key: string]: any;
|
|
693
|
+
});
|
|
694
|
+
}
|
|
695
|
+
export declare class QueryEdsAgentReportConfigRequest extends $tea.Model {
|
|
696
|
+
aliUid?: number;
|
|
697
|
+
desktopId?: string;
|
|
698
|
+
ecsInstanceId?: string;
|
|
699
|
+
static names(): {
|
|
700
|
+
[key: string]: string;
|
|
701
|
+
};
|
|
702
|
+
static types(): {
|
|
703
|
+
[key: string]: any;
|
|
704
|
+
};
|
|
705
|
+
constructor(map?: {
|
|
706
|
+
[key: string]: any;
|
|
707
|
+
});
|
|
708
|
+
}
|
|
709
|
+
export declare class QueryEdsAgentReportConfigResponseBody extends $tea.Model {
|
|
710
|
+
data?: QueryEdsAgentReportConfigResponseBodyData;
|
|
711
|
+
requestId?: string;
|
|
712
|
+
static names(): {
|
|
713
|
+
[key: string]: string;
|
|
714
|
+
};
|
|
715
|
+
static types(): {
|
|
716
|
+
[key: string]: any;
|
|
717
|
+
};
|
|
718
|
+
constructor(map?: {
|
|
719
|
+
[key: string]: any;
|
|
720
|
+
});
|
|
721
|
+
}
|
|
722
|
+
export declare class QueryEdsAgentReportConfigResponse extends $tea.Model {
|
|
723
|
+
headers?: {
|
|
724
|
+
[key: string]: string;
|
|
725
|
+
};
|
|
726
|
+
statusCode?: number;
|
|
727
|
+
body?: QueryEdsAgentReportConfigResponseBody;
|
|
728
|
+
static names(): {
|
|
729
|
+
[key: string]: string;
|
|
730
|
+
};
|
|
731
|
+
static types(): {
|
|
732
|
+
[key: string]: any;
|
|
733
|
+
};
|
|
734
|
+
constructor(map?: {
|
|
735
|
+
[key: string]: any;
|
|
736
|
+
});
|
|
737
|
+
}
|
|
738
|
+
export declare class RebootDesktopsRequest extends $tea.Model {
|
|
739
|
+
clientId?: string;
|
|
740
|
+
clientOS?: string;
|
|
741
|
+
clientToken?: string;
|
|
742
|
+
clientVersion?: string;
|
|
743
|
+
desktopId?: string[];
|
|
744
|
+
loginToken?: string;
|
|
745
|
+
regionId?: string;
|
|
746
|
+
sessionId?: string;
|
|
747
|
+
sessionToken?: string;
|
|
748
|
+
static names(): {
|
|
749
|
+
[key: string]: string;
|
|
750
|
+
};
|
|
751
|
+
static types(): {
|
|
752
|
+
[key: string]: any;
|
|
753
|
+
};
|
|
754
|
+
constructor(map?: {
|
|
755
|
+
[key: string]: any;
|
|
756
|
+
});
|
|
757
|
+
}
|
|
758
|
+
export declare class RebootDesktopsResponseBody extends $tea.Model {
|
|
759
|
+
requestId?: string;
|
|
760
|
+
static names(): {
|
|
761
|
+
[key: string]: string;
|
|
762
|
+
};
|
|
763
|
+
static types(): {
|
|
764
|
+
[key: string]: any;
|
|
765
|
+
};
|
|
766
|
+
constructor(map?: {
|
|
767
|
+
[key: string]: any;
|
|
768
|
+
});
|
|
769
|
+
}
|
|
770
|
+
export declare class RebootDesktopsResponse extends $tea.Model {
|
|
771
|
+
headers?: {
|
|
772
|
+
[key: string]: string;
|
|
773
|
+
};
|
|
774
|
+
statusCode?: number;
|
|
775
|
+
body?: RebootDesktopsResponseBody;
|
|
776
|
+
static names(): {
|
|
777
|
+
[key: string]: string;
|
|
778
|
+
};
|
|
779
|
+
static types(): {
|
|
780
|
+
[key: string]: any;
|
|
781
|
+
};
|
|
782
|
+
constructor(map?: {
|
|
783
|
+
[key: string]: any;
|
|
784
|
+
});
|
|
785
|
+
}
|
|
4
786
|
export declare class RefreshLoginTokenRequest extends $tea.Model {
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
787
|
+
clientId?: string;
|
|
788
|
+
directoryId?: string;
|
|
789
|
+
endUserId?: string;
|
|
790
|
+
loginToken?: string;
|
|
791
|
+
officeSiteId?: string;
|
|
792
|
+
regionId?: string;
|
|
793
|
+
sessionId?: string;
|
|
794
|
+
static names(): {
|
|
795
|
+
[key: string]: string;
|
|
796
|
+
};
|
|
797
|
+
static types(): {
|
|
798
|
+
[key: string]: any;
|
|
799
|
+
};
|
|
800
|
+
constructor(map?: {
|
|
801
|
+
[key: string]: any;
|
|
802
|
+
});
|
|
803
|
+
}
|
|
804
|
+
export declare class RefreshLoginTokenResponseBody extends $tea.Model {
|
|
805
|
+
loginToken?: string;
|
|
806
|
+
requestId?: string;
|
|
807
|
+
static names(): {
|
|
808
|
+
[key: string]: string;
|
|
809
|
+
};
|
|
810
|
+
static types(): {
|
|
811
|
+
[key: string]: any;
|
|
812
|
+
};
|
|
813
|
+
constructor(map?: {
|
|
814
|
+
[key: string]: any;
|
|
815
|
+
});
|
|
816
|
+
}
|
|
817
|
+
export declare class RefreshLoginTokenResponse extends $tea.Model {
|
|
818
|
+
headers?: {
|
|
819
|
+
[key: string]: string;
|
|
820
|
+
};
|
|
821
|
+
statusCode?: number;
|
|
822
|
+
body?: RefreshLoginTokenResponseBody;
|
|
823
|
+
static names(): {
|
|
824
|
+
[key: string]: string;
|
|
825
|
+
};
|
|
826
|
+
static types(): {
|
|
827
|
+
[key: string]: any;
|
|
828
|
+
};
|
|
829
|
+
constructor(map?: {
|
|
830
|
+
[key: string]: any;
|
|
831
|
+
});
|
|
832
|
+
}
|
|
833
|
+
export declare class ReportEdsAgentInfoRequest extends $tea.Model {
|
|
834
|
+
aliUid?: number;
|
|
835
|
+
desktopId?: string;
|
|
836
|
+
ecsInstanceId?: string;
|
|
837
|
+
edsAgentInfo?: string;
|
|
838
|
+
static names(): {
|
|
839
|
+
[key: string]: string;
|
|
840
|
+
};
|
|
841
|
+
static types(): {
|
|
842
|
+
[key: string]: any;
|
|
843
|
+
};
|
|
844
|
+
constructor(map?: {
|
|
845
|
+
[key: string]: any;
|
|
846
|
+
});
|
|
847
|
+
}
|
|
848
|
+
export declare class ReportEdsAgentInfoResponseBody extends $tea.Model {
|
|
849
|
+
requestId?: string;
|
|
850
|
+
static names(): {
|
|
851
|
+
[key: string]: string;
|
|
852
|
+
};
|
|
853
|
+
static types(): {
|
|
854
|
+
[key: string]: any;
|
|
855
|
+
};
|
|
856
|
+
constructor(map?: {
|
|
857
|
+
[key: string]: any;
|
|
858
|
+
});
|
|
859
|
+
}
|
|
860
|
+
export declare class ReportEdsAgentInfoResponse extends $tea.Model {
|
|
861
|
+
headers?: {
|
|
862
|
+
[key: string]: string;
|
|
863
|
+
};
|
|
864
|
+
statusCode?: number;
|
|
865
|
+
body?: ReportEdsAgentInfoResponseBody;
|
|
866
|
+
static names(): {
|
|
867
|
+
[key: string]: string;
|
|
868
|
+
};
|
|
869
|
+
static types(): {
|
|
870
|
+
[key: string]: any;
|
|
871
|
+
};
|
|
872
|
+
constructor(map?: {
|
|
873
|
+
[key: string]: any;
|
|
874
|
+
});
|
|
875
|
+
}
|
|
876
|
+
export declare class ReportSessionStatusRequest extends $tea.Model {
|
|
877
|
+
endUserId?: string;
|
|
878
|
+
instanceId?: string;
|
|
879
|
+
regionId?: string;
|
|
880
|
+
sessionChangeTime?: number;
|
|
881
|
+
sessionId?: string;
|
|
882
|
+
sessionStatus?: string;
|
|
883
|
+
static names(): {
|
|
884
|
+
[key: string]: string;
|
|
885
|
+
};
|
|
886
|
+
static types(): {
|
|
887
|
+
[key: string]: any;
|
|
888
|
+
};
|
|
889
|
+
constructor(map?: {
|
|
890
|
+
[key: string]: any;
|
|
891
|
+
});
|
|
892
|
+
}
|
|
893
|
+
export declare class ReportSessionStatusResponseBody extends $tea.Model {
|
|
894
|
+
requestId?: string;
|
|
895
|
+
static names(): {
|
|
896
|
+
[key: string]: string;
|
|
897
|
+
};
|
|
898
|
+
static types(): {
|
|
899
|
+
[key: string]: any;
|
|
900
|
+
};
|
|
901
|
+
constructor(map?: {
|
|
902
|
+
[key: string]: any;
|
|
903
|
+
});
|
|
904
|
+
}
|
|
905
|
+
export declare class ReportSessionStatusResponse extends $tea.Model {
|
|
906
|
+
headers?: {
|
|
907
|
+
[key: string]: string;
|
|
908
|
+
};
|
|
909
|
+
statusCode?: number;
|
|
910
|
+
body?: ReportSessionStatusResponseBody;
|
|
911
|
+
static names(): {
|
|
912
|
+
[key: string]: string;
|
|
913
|
+
};
|
|
914
|
+
static types(): {
|
|
915
|
+
[key: string]: any;
|
|
916
|
+
};
|
|
917
|
+
constructor(map?: {
|
|
918
|
+
[key: string]: any;
|
|
919
|
+
});
|
|
920
|
+
}
|
|
921
|
+
export declare class ResetPasswordRequest extends $tea.Model {
|
|
922
|
+
clientId?: string;
|
|
923
|
+
clientToken?: string;
|
|
924
|
+
email?: string;
|
|
925
|
+
endUserId?: string;
|
|
926
|
+
officeSiteId?: string;
|
|
927
|
+
regionId?: string;
|
|
928
|
+
phone?: string;
|
|
929
|
+
static names(): {
|
|
930
|
+
[key: string]: string;
|
|
931
|
+
};
|
|
932
|
+
static types(): {
|
|
933
|
+
[key: string]: any;
|
|
934
|
+
};
|
|
935
|
+
constructor(map?: {
|
|
936
|
+
[key: string]: any;
|
|
937
|
+
});
|
|
938
|
+
}
|
|
939
|
+
export declare class ResetPasswordResponseBody extends $tea.Model {
|
|
940
|
+
requestId?: string;
|
|
941
|
+
static names(): {
|
|
942
|
+
[key: string]: string;
|
|
943
|
+
};
|
|
944
|
+
static types(): {
|
|
945
|
+
[key: string]: any;
|
|
946
|
+
};
|
|
947
|
+
constructor(map?: {
|
|
948
|
+
[key: string]: any;
|
|
949
|
+
});
|
|
950
|
+
}
|
|
951
|
+
export declare class ResetPasswordResponse extends $tea.Model {
|
|
952
|
+
headers?: {
|
|
953
|
+
[key: string]: string;
|
|
954
|
+
};
|
|
955
|
+
statusCode?: number;
|
|
956
|
+
body?: ResetPasswordResponseBody;
|
|
957
|
+
static names(): {
|
|
958
|
+
[key: string]: string;
|
|
959
|
+
};
|
|
960
|
+
static types(): {
|
|
961
|
+
[key: string]: any;
|
|
962
|
+
};
|
|
963
|
+
constructor(map?: {
|
|
964
|
+
[key: string]: any;
|
|
965
|
+
});
|
|
966
|
+
}
|
|
967
|
+
export declare class ResetSnapshotRequest extends $tea.Model {
|
|
968
|
+
clientId?: string;
|
|
969
|
+
loginToken?: string;
|
|
970
|
+
regionId?: string;
|
|
971
|
+
sessionId?: string;
|
|
972
|
+
snapshotId?: string;
|
|
973
|
+
static names(): {
|
|
974
|
+
[key: string]: string;
|
|
975
|
+
};
|
|
976
|
+
static types(): {
|
|
977
|
+
[key: string]: any;
|
|
978
|
+
};
|
|
979
|
+
constructor(map?: {
|
|
980
|
+
[key: string]: any;
|
|
981
|
+
});
|
|
982
|
+
}
|
|
983
|
+
export declare class ResetSnapshotResponseBody extends $tea.Model {
|
|
984
|
+
requestId?: string;
|
|
985
|
+
static names(): {
|
|
986
|
+
[key: string]: string;
|
|
987
|
+
};
|
|
988
|
+
static types(): {
|
|
989
|
+
[key: string]: any;
|
|
990
|
+
};
|
|
991
|
+
constructor(map?: {
|
|
992
|
+
[key: string]: any;
|
|
993
|
+
});
|
|
994
|
+
}
|
|
995
|
+
export declare class ResetSnapshotResponse extends $tea.Model {
|
|
996
|
+
headers?: {
|
|
997
|
+
[key: string]: string;
|
|
998
|
+
};
|
|
999
|
+
statusCode?: number;
|
|
1000
|
+
body?: ResetSnapshotResponseBody;
|
|
1001
|
+
static names(): {
|
|
1002
|
+
[key: string]: string;
|
|
1003
|
+
};
|
|
1004
|
+
static types(): {
|
|
1005
|
+
[key: string]: any;
|
|
1006
|
+
};
|
|
1007
|
+
constructor(map?: {
|
|
1008
|
+
[key: string]: any;
|
|
1009
|
+
});
|
|
1010
|
+
}
|
|
1011
|
+
export declare class SendTokenCodeRequest extends $tea.Model {
|
|
1012
|
+
clientId?: string;
|
|
1013
|
+
clientOS?: string;
|
|
1014
|
+
clientVersion?: string;
|
|
1015
|
+
endUserId?: string;
|
|
1016
|
+
loginToken?: string;
|
|
1017
|
+
officeSiteId?: string;
|
|
1018
|
+
sessionId?: string;
|
|
1019
|
+
tokenCode?: string;
|
|
1020
|
+
static names(): {
|
|
1021
|
+
[key: string]: string;
|
|
1022
|
+
};
|
|
1023
|
+
static types(): {
|
|
1024
|
+
[key: string]: any;
|
|
1025
|
+
};
|
|
1026
|
+
constructor(map?: {
|
|
1027
|
+
[key: string]: any;
|
|
1028
|
+
});
|
|
1029
|
+
}
|
|
1030
|
+
export declare class SendTokenCodeResponseBody extends $tea.Model {
|
|
1031
|
+
requestId?: string;
|
|
1032
|
+
static names(): {
|
|
1033
|
+
[key: string]: string;
|
|
1034
|
+
};
|
|
1035
|
+
static types(): {
|
|
1036
|
+
[key: string]: any;
|
|
1037
|
+
};
|
|
1038
|
+
constructor(map?: {
|
|
1039
|
+
[key: string]: any;
|
|
1040
|
+
});
|
|
1041
|
+
}
|
|
1042
|
+
export declare class SendTokenCodeResponse extends $tea.Model {
|
|
1043
|
+
headers?: {
|
|
1044
|
+
[key: string]: string;
|
|
1045
|
+
};
|
|
1046
|
+
statusCode?: number;
|
|
1047
|
+
body?: SendTokenCodeResponseBody;
|
|
1048
|
+
static names(): {
|
|
1049
|
+
[key: string]: string;
|
|
1050
|
+
};
|
|
1051
|
+
static types(): {
|
|
1052
|
+
[key: string]: any;
|
|
1053
|
+
};
|
|
1054
|
+
constructor(map?: {
|
|
1055
|
+
[key: string]: any;
|
|
1056
|
+
});
|
|
1057
|
+
}
|
|
1058
|
+
export declare class SetFingerPrintTemplateRequest extends $tea.Model {
|
|
1059
|
+
clientId?: string;
|
|
1060
|
+
clientToken?: string;
|
|
1061
|
+
description?: string;
|
|
1062
|
+
encryptedFingerPrintTemplate?: string;
|
|
1063
|
+
encryptedKey?: string;
|
|
1064
|
+
fingerPrintTemplate?: string;
|
|
1065
|
+
loginToken?: string;
|
|
1066
|
+
password?: string;
|
|
1067
|
+
regionId?: string;
|
|
1068
|
+
sessionId?: string;
|
|
1069
|
+
static names(): {
|
|
1070
|
+
[key: string]: string;
|
|
1071
|
+
};
|
|
1072
|
+
static types(): {
|
|
1073
|
+
[key: string]: any;
|
|
1074
|
+
};
|
|
1075
|
+
constructor(map?: {
|
|
1076
|
+
[key: string]: any;
|
|
1077
|
+
});
|
|
1078
|
+
}
|
|
1079
|
+
export declare class SetFingerPrintTemplateResponseBody extends $tea.Model {
|
|
1080
|
+
encryptedPassword?: string;
|
|
1081
|
+
index?: number;
|
|
1082
|
+
requestId?: string;
|
|
1083
|
+
static names(): {
|
|
1084
|
+
[key: string]: string;
|
|
1085
|
+
};
|
|
1086
|
+
static types(): {
|
|
1087
|
+
[key: string]: any;
|
|
1088
|
+
};
|
|
1089
|
+
constructor(map?: {
|
|
1090
|
+
[key: string]: any;
|
|
1091
|
+
});
|
|
1092
|
+
}
|
|
1093
|
+
export declare class SetFingerPrintTemplateResponse extends $tea.Model {
|
|
1094
|
+
headers?: {
|
|
1095
|
+
[key: string]: string;
|
|
1096
|
+
};
|
|
1097
|
+
statusCode?: number;
|
|
1098
|
+
body?: SetFingerPrintTemplateResponseBody;
|
|
10
1099
|
static names(): {
|
|
11
1100
|
[key: string]: string;
|
|
12
1101
|
};
|
|
@@ -17,8 +1106,14 @@ export declare class RefreshLoginTokenRequest extends $tea.Model {
|
|
|
17
1106
|
[key: string]: any;
|
|
18
1107
|
});
|
|
19
1108
|
}
|
|
20
|
-
export declare class
|
|
21
|
-
|
|
1109
|
+
export declare class SetFingerPrintTemplateDescriptionRequest extends $tea.Model {
|
|
1110
|
+
clientId?: string;
|
|
1111
|
+
clientToken?: string;
|
|
1112
|
+
description?: string;
|
|
1113
|
+
index?: number;
|
|
1114
|
+
loginToken?: string;
|
|
1115
|
+
regionId?: string;
|
|
1116
|
+
sessionId?: string;
|
|
22
1117
|
static names(): {
|
|
23
1118
|
[key: string]: string;
|
|
24
1119
|
};
|
|
@@ -29,10 +1124,8 @@ export declare class RefreshLoginTokenResponse extends $tea.Model {
|
|
|
29
1124
|
[key: string]: any;
|
|
30
1125
|
});
|
|
31
1126
|
}
|
|
32
|
-
export declare class
|
|
33
|
-
|
|
34
|
-
clientId: string;
|
|
35
|
-
directoryId?: string[];
|
|
1127
|
+
export declare class SetFingerPrintTemplateDescriptionResponseBody extends $tea.Model {
|
|
1128
|
+
requestId?: string;
|
|
36
1129
|
static names(): {
|
|
37
1130
|
[key: string]: string;
|
|
38
1131
|
};
|
|
@@ -43,9 +1136,12 @@ export declare class DescribeDirectoriesRequest extends $tea.Model {
|
|
|
43
1136
|
[key: string]: any;
|
|
44
1137
|
});
|
|
45
1138
|
}
|
|
46
|
-
export declare class
|
|
47
|
-
|
|
48
|
-
|
|
1139
|
+
export declare class SetFingerPrintTemplateDescriptionResponse extends $tea.Model {
|
|
1140
|
+
headers?: {
|
|
1141
|
+
[key: string]: string;
|
|
1142
|
+
};
|
|
1143
|
+
statusCode?: number;
|
|
1144
|
+
body?: SetFingerPrintTemplateDescriptionResponseBody;
|
|
49
1145
|
static names(): {
|
|
50
1146
|
[key: string]: string;
|
|
51
1147
|
};
|
|
@@ -56,18 +1152,15 @@ export declare class DescribeDirectoriesResponse extends $tea.Model {
|
|
|
56
1152
|
[key: string]: any;
|
|
57
1153
|
});
|
|
58
1154
|
}
|
|
59
|
-
export declare class
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
groupId?: string;
|
|
65
|
-
desktopStatus?: string;
|
|
66
|
-
maxResults?: number;
|
|
67
|
-
nextToken?: string;
|
|
68
|
-
userName?: string;
|
|
69
|
-
desktopName?: string;
|
|
1155
|
+
export declare class StartDesktopsRequest extends $tea.Model {
|
|
1156
|
+
clientId?: string;
|
|
1157
|
+
clientOS?: string;
|
|
1158
|
+
clientToken?: string;
|
|
1159
|
+
clientVersion?: string;
|
|
70
1160
|
desktopId?: string[];
|
|
1161
|
+
loginToken?: string;
|
|
1162
|
+
regionId?: string;
|
|
1163
|
+
sessionId?: string;
|
|
71
1164
|
static names(): {
|
|
72
1165
|
[key: string]: string;
|
|
73
1166
|
};
|
|
@@ -78,10 +1171,8 @@ export declare class DescribeDesktopsRequest extends $tea.Model {
|
|
|
78
1171
|
[key: string]: any;
|
|
79
1172
|
});
|
|
80
1173
|
}
|
|
81
|
-
export declare class
|
|
82
|
-
requestId
|
|
83
|
-
nextToken: string;
|
|
84
|
-
desktops: DescribeDesktopsResponseDesktops[];
|
|
1174
|
+
export declare class StartDesktopsResponseBody extends $tea.Model {
|
|
1175
|
+
requestId?: string;
|
|
85
1176
|
static names(): {
|
|
86
1177
|
[key: string]: string;
|
|
87
1178
|
};
|
|
@@ -92,11 +1183,12 @@ export declare class DescribeDesktopsResponse extends $tea.Model {
|
|
|
92
1183
|
[key: string]: any;
|
|
93
1184
|
});
|
|
94
1185
|
}
|
|
95
|
-
export declare class
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
1186
|
+
export declare class StartDesktopsResponse extends $tea.Model {
|
|
1187
|
+
headers?: {
|
|
1188
|
+
[key: string]: string;
|
|
1189
|
+
};
|
|
1190
|
+
statusCode?: number;
|
|
1191
|
+
body?: StartDesktopsResponseBody;
|
|
100
1192
|
static names(): {
|
|
101
1193
|
[key: string]: string;
|
|
102
1194
|
};
|
|
@@ -107,8 +1199,15 @@ export declare class RebootDesktopsRequest extends $tea.Model {
|
|
|
107
1199
|
[key: string]: any;
|
|
108
1200
|
});
|
|
109
1201
|
}
|
|
110
|
-
export declare class
|
|
111
|
-
|
|
1202
|
+
export declare class StartRecordContentRequest extends $tea.Model {
|
|
1203
|
+
clientId?: string;
|
|
1204
|
+
clientOS?: string;
|
|
1205
|
+
clientVersion?: string;
|
|
1206
|
+
desktopId?: string;
|
|
1207
|
+
filePath?: string;
|
|
1208
|
+
loginToken?: string;
|
|
1209
|
+
regionId?: string;
|
|
1210
|
+
sessionId?: string;
|
|
112
1211
|
static names(): {
|
|
113
1212
|
[key: string]: string;
|
|
114
1213
|
};
|
|
@@ -119,12 +1218,90 @@ export declare class RebootDesktopsResponse extends $tea.Model {
|
|
|
119
1218
|
[key: string]: any;
|
|
120
1219
|
});
|
|
121
1220
|
}
|
|
122
|
-
export declare class
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
1221
|
+
export declare class StartRecordContentResponseBody extends $tea.Model {
|
|
1222
|
+
requestId?: string;
|
|
1223
|
+
static names(): {
|
|
1224
|
+
[key: string]: string;
|
|
1225
|
+
};
|
|
1226
|
+
static types(): {
|
|
1227
|
+
[key: string]: any;
|
|
1228
|
+
};
|
|
1229
|
+
constructor(map?: {
|
|
1230
|
+
[key: string]: any;
|
|
1231
|
+
});
|
|
1232
|
+
}
|
|
1233
|
+
export declare class StartRecordContentResponse extends $tea.Model {
|
|
1234
|
+
headers?: {
|
|
1235
|
+
[key: string]: string;
|
|
1236
|
+
};
|
|
1237
|
+
statusCode?: number;
|
|
1238
|
+
body?: StartRecordContentResponseBody;
|
|
1239
|
+
static names(): {
|
|
1240
|
+
[key: string]: string;
|
|
1241
|
+
};
|
|
1242
|
+
static types(): {
|
|
1243
|
+
[key: string]: any;
|
|
1244
|
+
};
|
|
1245
|
+
constructor(map?: {
|
|
1246
|
+
[key: string]: any;
|
|
1247
|
+
});
|
|
1248
|
+
}
|
|
1249
|
+
export declare class StopDesktopsRequest extends $tea.Model {
|
|
1250
|
+
clientId?: string;
|
|
1251
|
+
clientOS?: string;
|
|
1252
|
+
clientToken?: string;
|
|
1253
|
+
clientVersion?: string;
|
|
1254
|
+
desktopId?: string[];
|
|
1255
|
+
loginToken?: string;
|
|
1256
|
+
regionId?: string;
|
|
1257
|
+
sessionId?: string;
|
|
1258
|
+
sessionToken?: string;
|
|
1259
|
+
static names(): {
|
|
1260
|
+
[key: string]: string;
|
|
1261
|
+
};
|
|
1262
|
+
static types(): {
|
|
1263
|
+
[key: string]: any;
|
|
1264
|
+
};
|
|
1265
|
+
constructor(map?: {
|
|
1266
|
+
[key: string]: any;
|
|
1267
|
+
});
|
|
1268
|
+
}
|
|
1269
|
+
export declare class StopDesktopsResponseBody extends $tea.Model {
|
|
1270
|
+
requestId?: string;
|
|
1271
|
+
static names(): {
|
|
1272
|
+
[key: string]: string;
|
|
1273
|
+
};
|
|
1274
|
+
static types(): {
|
|
1275
|
+
[key: string]: any;
|
|
1276
|
+
};
|
|
1277
|
+
constructor(map?: {
|
|
1278
|
+
[key: string]: any;
|
|
1279
|
+
});
|
|
1280
|
+
}
|
|
1281
|
+
export declare class StopDesktopsResponse extends $tea.Model {
|
|
1282
|
+
headers?: {
|
|
1283
|
+
[key: string]: string;
|
|
1284
|
+
};
|
|
1285
|
+
statusCode?: number;
|
|
1286
|
+
body?: StopDesktopsResponseBody;
|
|
1287
|
+
static names(): {
|
|
1288
|
+
[key: string]: string;
|
|
1289
|
+
};
|
|
1290
|
+
static types(): {
|
|
1291
|
+
[key: string]: any;
|
|
1292
|
+
};
|
|
1293
|
+
constructor(map?: {
|
|
1294
|
+
[key: string]: any;
|
|
1295
|
+
});
|
|
1296
|
+
}
|
|
1297
|
+
export declare class StopRecordContentRequest extends $tea.Model {
|
|
1298
|
+
clientId?: string;
|
|
1299
|
+
clientOS?: string;
|
|
1300
|
+
clientVersion?: string;
|
|
127
1301
|
desktopId?: string;
|
|
1302
|
+
loginToken?: string;
|
|
1303
|
+
regionId?: string;
|
|
1304
|
+
sessionId?: string;
|
|
128
1305
|
static names(): {
|
|
129
1306
|
[key: string]: string;
|
|
130
1307
|
};
|
|
@@ -135,11 +1312,8 @@ export declare class GetConnectionTicketRequest extends $tea.Model {
|
|
|
135
1312
|
[key: string]: any;
|
|
136
1313
|
});
|
|
137
1314
|
}
|
|
138
|
-
export declare class
|
|
139
|
-
requestId
|
|
140
|
-
taskId: string;
|
|
141
|
-
taskStatus: string;
|
|
142
|
-
ticket: string;
|
|
1315
|
+
export declare class StopRecordContentResponseBody extends $tea.Model {
|
|
1316
|
+
requestId?: string;
|
|
143
1317
|
static names(): {
|
|
144
1318
|
[key: string]: string;
|
|
145
1319
|
};
|
|
@@ -150,12 +1324,12 @@ export declare class GetConnectionTicketResponse extends $tea.Model {
|
|
|
150
1324
|
[key: string]: any;
|
|
151
1325
|
});
|
|
152
1326
|
}
|
|
153
|
-
export declare class
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
1327
|
+
export declare class StopRecordContentResponse extends $tea.Model {
|
|
1328
|
+
headers?: {
|
|
1329
|
+
[key: string]: string;
|
|
1330
|
+
};
|
|
1331
|
+
statusCode?: number;
|
|
1332
|
+
body?: StopRecordContentResponseBody;
|
|
159
1333
|
static names(): {
|
|
160
1334
|
[key: string]: string;
|
|
161
1335
|
};
|
|
@@ -166,9 +1340,14 @@ export declare class GetLoginTokenRequest extends $tea.Model {
|
|
|
166
1340
|
[key: string]: any;
|
|
167
1341
|
});
|
|
168
1342
|
}
|
|
169
|
-
export declare class
|
|
170
|
-
|
|
171
|
-
|
|
1343
|
+
export declare class UnbindUserDesktopRequest extends $tea.Model {
|
|
1344
|
+
clientId?: string;
|
|
1345
|
+
clientType?: string;
|
|
1346
|
+
force?: boolean;
|
|
1347
|
+
loginToken?: string;
|
|
1348
|
+
regionId?: string;
|
|
1349
|
+
sessionId?: string;
|
|
1350
|
+
userDesktopId?: string;
|
|
172
1351
|
static names(): {
|
|
173
1352
|
[key: string]: string;
|
|
174
1353
|
};
|
|
@@ -179,9 +1358,8 @@ export declare class GetLoginTokenResponse extends $tea.Model {
|
|
|
179
1358
|
[key: string]: any;
|
|
180
1359
|
});
|
|
181
1360
|
}
|
|
182
|
-
export declare class
|
|
183
|
-
|
|
184
|
-
directoryType: string;
|
|
1361
|
+
export declare class UnbindUserDesktopResponseBody extends $tea.Model {
|
|
1362
|
+
requestId?: string;
|
|
185
1363
|
static names(): {
|
|
186
1364
|
[key: string]: string;
|
|
187
1365
|
};
|
|
@@ -192,10 +1370,12 @@ export declare class DescribeDirectoriesResponseDirectories extends $tea.Model {
|
|
|
192
1370
|
[key: string]: any;
|
|
193
1371
|
});
|
|
194
1372
|
}
|
|
195
|
-
export declare class
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
1373
|
+
export declare class UnbindUserDesktopResponse extends $tea.Model {
|
|
1374
|
+
headers?: {
|
|
1375
|
+
[key: string]: string;
|
|
1376
|
+
};
|
|
1377
|
+
statusCode?: number;
|
|
1378
|
+
body?: UnbindUserDesktopResponseBody;
|
|
199
1379
|
static names(): {
|
|
200
1380
|
[key: string]: string;
|
|
201
1381
|
};
|
|
@@ -206,25 +1386,15 @@ export declare class DescribeDesktopsResponseDesktopsDisks extends $tea.Model {
|
|
|
206
1386
|
[key: string]: any;
|
|
207
1387
|
});
|
|
208
1388
|
}
|
|
209
|
-
export declare class
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
systemDiskSize: number;
|
|
219
|
-
dataDiskCategory: string;
|
|
220
|
-
dataDiskSize: string;
|
|
221
|
-
connectionStatus: string;
|
|
222
|
-
policyGroupId: string;
|
|
223
|
-
cpu: number;
|
|
224
|
-
memory: number;
|
|
225
|
-
networkInterfaceId: number;
|
|
226
|
-
disks: DescribeDesktopsResponseDesktopsDisks[];
|
|
227
|
-
endUserIds: string[];
|
|
1389
|
+
export declare class VerifyCredentialRequest extends $tea.Model {
|
|
1390
|
+
clientId?: string;
|
|
1391
|
+
credential?: string;
|
|
1392
|
+
credentialType?: string;
|
|
1393
|
+
encryptedKey?: string;
|
|
1394
|
+
loginToken?: string;
|
|
1395
|
+
officeSiteId?: string;
|
|
1396
|
+
regionId?: string;
|
|
1397
|
+
sessionId?: string;
|
|
228
1398
|
static names(): {
|
|
229
1399
|
[key: string]: string;
|
|
230
1400
|
};
|
|
@@ -235,21 +1405,366 @@ export declare class DescribeDesktopsResponseDesktops extends $tea.Model {
|
|
|
235
1405
|
[key: string]: any;
|
|
236
1406
|
});
|
|
237
1407
|
}
|
|
238
|
-
export
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
1408
|
+
export declare class VerifyCredentialResponseBody extends $tea.Model {
|
|
1409
|
+
requestId?: string;
|
|
1410
|
+
static names(): {
|
|
1411
|
+
[key: string]: string;
|
|
1412
|
+
};
|
|
1413
|
+
static types(): {
|
|
1414
|
+
[key: string]: any;
|
|
1415
|
+
};
|
|
1416
|
+
constructor(map?: {
|
|
1417
|
+
[key: string]: any;
|
|
1418
|
+
});
|
|
1419
|
+
}
|
|
1420
|
+
export declare class VerifyCredentialResponse extends $tea.Model {
|
|
1421
|
+
headers?: {
|
|
1422
|
+
[key: string]: string;
|
|
1423
|
+
};
|
|
1424
|
+
statusCode?: number;
|
|
1425
|
+
body?: VerifyCredentialResponseBody;
|
|
1426
|
+
static names(): {
|
|
1427
|
+
[key: string]: string;
|
|
1428
|
+
};
|
|
1429
|
+
static types(): {
|
|
1430
|
+
[key: string]: any;
|
|
1431
|
+
};
|
|
1432
|
+
constructor(map?: {
|
|
1433
|
+
[key: string]: any;
|
|
1434
|
+
});
|
|
1435
|
+
}
|
|
1436
|
+
export declare class DescribeDirectoriesResponseBodyDirectories extends $tea.Model {
|
|
1437
|
+
desktopAccessType?: string;
|
|
1438
|
+
directoryId?: string;
|
|
1439
|
+
directoryType?: string;
|
|
1440
|
+
providerId?: string;
|
|
1441
|
+
ssoServiceUrl?: string;
|
|
1442
|
+
static names(): {
|
|
1443
|
+
[key: string]: string;
|
|
1444
|
+
};
|
|
1445
|
+
static types(): {
|
|
1446
|
+
[key: string]: any;
|
|
1447
|
+
};
|
|
1448
|
+
constructor(map?: {
|
|
1449
|
+
[key: string]: any;
|
|
1450
|
+
});
|
|
1451
|
+
}
|
|
1452
|
+
export declare class DescribeFingerPrintTemplatesResponseBodyFingerPrintTemplates extends $tea.Model {
|
|
1453
|
+
clientId?: string;
|
|
1454
|
+
creationTime?: string;
|
|
1455
|
+
description?: string;
|
|
1456
|
+
endUserId?: string;
|
|
1457
|
+
index?: number;
|
|
1458
|
+
loginTime?: string;
|
|
1459
|
+
officeSiteId?: string;
|
|
1460
|
+
static names(): {
|
|
1461
|
+
[key: string]: string;
|
|
1462
|
+
};
|
|
1463
|
+
static types(): {
|
|
1464
|
+
[key: string]: any;
|
|
1465
|
+
};
|
|
1466
|
+
constructor(map?: {
|
|
1467
|
+
[key: string]: any;
|
|
1468
|
+
});
|
|
1469
|
+
}
|
|
1470
|
+
export declare class DescribeGlobalDesktopsResponseBodyDesktopsClients extends $tea.Model {
|
|
1471
|
+
clientType?: string;
|
|
1472
|
+
status?: string;
|
|
1473
|
+
static names(): {
|
|
1474
|
+
[key: string]: string;
|
|
1475
|
+
};
|
|
1476
|
+
static types(): {
|
|
1477
|
+
[key: string]: any;
|
|
1478
|
+
};
|
|
1479
|
+
constructor(map?: {
|
|
1480
|
+
[key: string]: any;
|
|
1481
|
+
});
|
|
1482
|
+
}
|
|
1483
|
+
export declare class DescribeGlobalDesktopsResponseBodyDesktopsDesktopTimers extends $tea.Model {
|
|
1484
|
+
allowClientSetting?: boolean;
|
|
1485
|
+
cronExpression?: string;
|
|
1486
|
+
enforce?: boolean;
|
|
1487
|
+
executionTime?: string;
|
|
1488
|
+
interval?: number;
|
|
1489
|
+
operationType?: string;
|
|
1490
|
+
resetType?: string;
|
|
1491
|
+
timerType?: string;
|
|
1492
|
+
static names(): {
|
|
1493
|
+
[key: string]: string;
|
|
1494
|
+
};
|
|
1495
|
+
static types(): {
|
|
1496
|
+
[key: string]: any;
|
|
1497
|
+
};
|
|
1498
|
+
constructor(map?: {
|
|
1499
|
+
[key: string]: any;
|
|
1500
|
+
});
|
|
1501
|
+
}
|
|
1502
|
+
export declare class DescribeGlobalDesktopsResponseBodyDesktopsDisks extends $tea.Model {
|
|
1503
|
+
diskId?: string;
|
|
1504
|
+
diskSize?: number;
|
|
1505
|
+
diskType?: string;
|
|
1506
|
+
static names(): {
|
|
1507
|
+
[key: string]: string;
|
|
1508
|
+
};
|
|
1509
|
+
static types(): {
|
|
1510
|
+
[key: string]: any;
|
|
1511
|
+
};
|
|
1512
|
+
constructor(map?: {
|
|
1513
|
+
[key: string]: any;
|
|
1514
|
+
});
|
|
1515
|
+
}
|
|
1516
|
+
export declare class DescribeGlobalDesktopsResponseBodyDesktopsFotaUpdate extends $tea.Model {
|
|
1517
|
+
channel?: string;
|
|
1518
|
+
currentAppVersion?: string;
|
|
1519
|
+
force?: boolean;
|
|
1520
|
+
newAppVersion?: string;
|
|
1521
|
+
project?: string;
|
|
1522
|
+
releaseNote?: string;
|
|
1523
|
+
releaseNoteEn?: string;
|
|
1524
|
+
releaseNoteJp?: string;
|
|
1525
|
+
size?: string;
|
|
1526
|
+
static names(): {
|
|
1527
|
+
[key: string]: string;
|
|
1528
|
+
};
|
|
1529
|
+
static types(): {
|
|
1530
|
+
[key: string]: any;
|
|
1531
|
+
};
|
|
1532
|
+
constructor(map?: {
|
|
1533
|
+
[key: string]: any;
|
|
1534
|
+
});
|
|
1535
|
+
}
|
|
1536
|
+
export declare class DescribeGlobalDesktopsResponseBodyDesktopsSessions extends $tea.Model {
|
|
1537
|
+
endUserId?: string;
|
|
1538
|
+
establishmentTime?: string;
|
|
1539
|
+
static names(): {
|
|
1540
|
+
[key: string]: string;
|
|
1541
|
+
};
|
|
1542
|
+
static types(): {
|
|
1543
|
+
[key: string]: any;
|
|
1544
|
+
};
|
|
1545
|
+
constructor(map?: {
|
|
1546
|
+
[key: string]: any;
|
|
1547
|
+
});
|
|
1548
|
+
}
|
|
1549
|
+
export declare class DescribeGlobalDesktopsResponseBodyDesktops extends $tea.Model {
|
|
1550
|
+
chargeType?: string;
|
|
1551
|
+
clients?: DescribeGlobalDesktopsResponseBodyDesktopsClients[];
|
|
1552
|
+
connectionStatus?: string;
|
|
1553
|
+
cpu?: number;
|
|
1554
|
+
creationTime?: string;
|
|
1555
|
+
desktopGroupId?: string;
|
|
1556
|
+
desktopId?: string;
|
|
1557
|
+
desktopName?: string;
|
|
1558
|
+
desktopStatus?: string;
|
|
1559
|
+
desktopTimers?: DescribeGlobalDesktopsResponseBodyDesktopsDesktopTimers[];
|
|
1560
|
+
desktopType?: string;
|
|
1561
|
+
directoryId?: string;
|
|
1562
|
+
disks?: DescribeGlobalDesktopsResponseBodyDesktopsDisks[];
|
|
1563
|
+
endUserId?: string;
|
|
1564
|
+
endUserIds?: string[];
|
|
1565
|
+
expiredTime?: string;
|
|
1566
|
+
fotaUpdate?: DescribeGlobalDesktopsResponseBodyDesktopsFotaUpdate;
|
|
1567
|
+
gpuMemory?: number;
|
|
1568
|
+
hibernationBeta?: boolean;
|
|
1569
|
+
hostName?: string;
|
|
1570
|
+
imageId?: string;
|
|
1571
|
+
lastStartTime?: string;
|
|
1572
|
+
localName?: string;
|
|
1573
|
+
managementFlags?: string[];
|
|
1574
|
+
memory?: number;
|
|
1575
|
+
networkInterfaceIp?: string;
|
|
1576
|
+
officeSiteId?: string;
|
|
1577
|
+
os?: string;
|
|
1578
|
+
osType?: string;
|
|
1579
|
+
platform?: string;
|
|
1580
|
+
policyGroupId?: string;
|
|
1581
|
+
protocolType?: string;
|
|
1582
|
+
realDesktopId?: string;
|
|
1583
|
+
regionId?: string;
|
|
1584
|
+
sessionType?: string;
|
|
1585
|
+
sessions?: DescribeGlobalDesktopsResponseBodyDesktopsSessions[];
|
|
1586
|
+
supportHibernation?: boolean;
|
|
1587
|
+
userCustomName?: string;
|
|
1588
|
+
static names(): {
|
|
1589
|
+
[key: string]: string;
|
|
1590
|
+
};
|
|
1591
|
+
static types(): {
|
|
1592
|
+
[key: string]: any;
|
|
1593
|
+
};
|
|
1594
|
+
constructor(map?: {
|
|
1595
|
+
[key: string]: any;
|
|
1596
|
+
});
|
|
1597
|
+
}
|
|
1598
|
+
export declare class DescribeOfficeSitesResponseBodyOfficeSites extends $tea.Model {
|
|
1599
|
+
desktopAccessType?: string;
|
|
1600
|
+
desktopVpcEndpoint?: string;
|
|
1601
|
+
officeSiteId?: string;
|
|
1602
|
+
officeSiteType?: string;
|
|
1603
|
+
providerId?: string;
|
|
1604
|
+
ssoServiceUrl?: string;
|
|
1605
|
+
static names(): {
|
|
1606
|
+
[key: string]: string;
|
|
1607
|
+
};
|
|
1608
|
+
static types(): {
|
|
1609
|
+
[key: string]: any;
|
|
1610
|
+
};
|
|
1611
|
+
constructor(map?: {
|
|
1612
|
+
[key: string]: any;
|
|
1613
|
+
});
|
|
1614
|
+
}
|
|
1615
|
+
export declare class DescribeRegionsResponseBodyRegions extends $tea.Model {
|
|
1616
|
+
regionEndpoint?: string;
|
|
1617
|
+
regionId?: string;
|
|
1618
|
+
static names(): {
|
|
1619
|
+
[key: string]: string;
|
|
1620
|
+
};
|
|
1621
|
+
static types(): {
|
|
1622
|
+
[key: string]: any;
|
|
1623
|
+
};
|
|
1624
|
+
constructor(map?: {
|
|
1625
|
+
[key: string]: any;
|
|
1626
|
+
});
|
|
1627
|
+
}
|
|
1628
|
+
export declare class DescribeSnapshotsResponseBodySnapshots extends $tea.Model {
|
|
1629
|
+
creationTime?: string;
|
|
1630
|
+
description?: string;
|
|
1631
|
+
desktopId?: string;
|
|
1632
|
+
progress?: string;
|
|
1633
|
+
remainTime?: number;
|
|
1634
|
+
snapshotId?: string;
|
|
1635
|
+
snapshotName?: string;
|
|
1636
|
+
snapshotType?: string;
|
|
1637
|
+
sourceDiskSize?: string;
|
|
1638
|
+
sourceDiskType?: string;
|
|
1639
|
+
status?: string;
|
|
1640
|
+
static names(): {
|
|
1641
|
+
[key: string]: string;
|
|
1642
|
+
};
|
|
1643
|
+
static types(): {
|
|
1644
|
+
[key: string]: any;
|
|
1645
|
+
};
|
|
1646
|
+
constructor(map?: {
|
|
1647
|
+
[key: string]: any;
|
|
1648
|
+
});
|
|
1649
|
+
}
|
|
1650
|
+
export declare class GetCloudDriveServiceMountTokenResponseBodyToken extends $tea.Model {
|
|
1651
|
+
domainId?: string;
|
|
1652
|
+
expiredAfter?: string;
|
|
1653
|
+
status?: string;
|
|
1654
|
+
token?: string;
|
|
1655
|
+
totalSize?: number;
|
|
1656
|
+
usedSize?: number;
|
|
1657
|
+
static names(): {
|
|
1658
|
+
[key: string]: string;
|
|
1659
|
+
};
|
|
1660
|
+
static types(): {
|
|
1661
|
+
[key: string]: any;
|
|
1662
|
+
};
|
|
1663
|
+
constructor(map?: {
|
|
1664
|
+
[key: string]: any;
|
|
1665
|
+
});
|
|
1666
|
+
}
|
|
1667
|
+
export declare class QueryEdsAgentReportConfigResponseBodyData extends $tea.Model {
|
|
1668
|
+
config?: string;
|
|
1669
|
+
static names(): {
|
|
1670
|
+
[key: string]: string;
|
|
1671
|
+
};
|
|
1672
|
+
static types(): {
|
|
1673
|
+
[key: string]: any;
|
|
1674
|
+
};
|
|
1675
|
+
constructor(map?: {
|
|
1676
|
+
[key: string]: any;
|
|
1677
|
+
});
|
|
1678
|
+
}
|
|
1679
|
+
export default class Client extends OpenApi {
|
|
1680
|
+
constructor(config: $OpenApi.Config);
|
|
1681
|
+
getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: {
|
|
1682
|
+
[key: string]: string;
|
|
1683
|
+
}, endpoint: string): string;
|
|
1684
|
+
approveFotaUpdateWithOptions(request: ApproveFotaUpdateRequest, runtime: $Util.RuntimeOptions): Promise<ApproveFotaUpdateResponse>;
|
|
1685
|
+
approveFotaUpdate(request: ApproveFotaUpdateRequest): Promise<ApproveFotaUpdateResponse>;
|
|
1686
|
+
changePasswordWithOptions(request: ChangePasswordRequest, runtime: $Util.RuntimeOptions): Promise<ChangePasswordResponse>;
|
|
1687
|
+
changePassword(request: ChangePasswordRequest): Promise<ChangePasswordResponse>;
|
|
1688
|
+
deleteFingerPrintTemplateWithOptions(request: DeleteFingerPrintTemplateRequest, runtime: $Util.RuntimeOptions): Promise<DeleteFingerPrintTemplateResponse>;
|
|
1689
|
+
deleteFingerPrintTemplate(request: DeleteFingerPrintTemplateRequest): Promise<DeleteFingerPrintTemplateResponse>;
|
|
242
1690
|
describeDirectoriesWithOptions(request: DescribeDirectoriesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeDirectoriesResponse>;
|
|
243
1691
|
describeDirectories(request: DescribeDirectoriesRequest): Promise<DescribeDirectoriesResponse>;
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
1692
|
+
describeFingerPrintTemplatesWithOptions(request: DescribeFingerPrintTemplatesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeFingerPrintTemplatesResponse>;
|
|
1693
|
+
describeFingerPrintTemplates(request: DescribeFingerPrintTemplatesRequest): Promise<DescribeFingerPrintTemplatesResponse>;
|
|
1694
|
+
describeGlobalDesktopsWithOptions(request: DescribeGlobalDesktopsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeGlobalDesktopsResponse>;
|
|
1695
|
+
describeGlobalDesktops(request: DescribeGlobalDesktopsRequest): Promise<DescribeGlobalDesktopsResponse>;
|
|
1696
|
+
describeOfficeSitesWithOptions(request: DescribeOfficeSitesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeOfficeSitesResponse>;
|
|
1697
|
+
describeOfficeSites(request: DescribeOfficeSitesRequest): Promise<DescribeOfficeSitesResponse>;
|
|
1698
|
+
describeRegionsWithOptions(request: DescribeRegionsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeRegionsResponse>;
|
|
1699
|
+
describeRegions(request: DescribeRegionsRequest): Promise<DescribeRegionsResponse>;
|
|
1700
|
+
describeSnapshotsWithOptions(request: DescribeSnapshotsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeSnapshotsResponse>;
|
|
1701
|
+
describeSnapshots(request: DescribeSnapshotsRequest): Promise<DescribeSnapshotsResponse>;
|
|
1702
|
+
encryptPasswordWithOptions(request: EncryptPasswordRequest, runtime: $Util.RuntimeOptions): Promise<EncryptPasswordResponse>;
|
|
1703
|
+
encryptPassword(request: EncryptPasswordRequest): Promise<EncryptPasswordResponse>;
|
|
1704
|
+
getCloudDriveServiceMountTokenWithOptions(request: GetCloudDriveServiceMountTokenRequest, runtime: $Util.RuntimeOptions): Promise<GetCloudDriveServiceMountTokenResponse>;
|
|
1705
|
+
getCloudDriveServiceMountToken(request: GetCloudDriveServiceMountTokenRequest): Promise<GetCloudDriveServiceMountTokenResponse>;
|
|
248
1706
|
getConnectionTicketWithOptions(request: GetConnectionTicketRequest, runtime: $Util.RuntimeOptions): Promise<GetConnectionTicketResponse>;
|
|
249
1707
|
getConnectionTicket(request: GetConnectionTicketRequest): Promise<GetConnectionTicketResponse>;
|
|
250
1708
|
getLoginTokenWithOptions(request: GetLoginTokenRequest, runtime: $Util.RuntimeOptions): Promise<GetLoginTokenResponse>;
|
|
251
1709
|
getLoginToken(request: GetLoginTokenRequest): Promise<GetLoginTokenResponse>;
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
1710
|
+
isKeepAliveWithOptions(request: IsKeepAliveRequest, runtime: $Util.RuntimeOptions): Promise<IsKeepAliveResponse>;
|
|
1711
|
+
isKeepAlive(request: IsKeepAliveRequest): Promise<IsKeepAliveResponse>;
|
|
1712
|
+
queryEdsAgentReportConfigWithOptions(request: QueryEdsAgentReportConfigRequest, runtime: $Util.RuntimeOptions): Promise<QueryEdsAgentReportConfigResponse>;
|
|
1713
|
+
queryEdsAgentReportConfig(request: QueryEdsAgentReportConfigRequest): Promise<QueryEdsAgentReportConfigResponse>;
|
|
1714
|
+
rebootDesktopsWithOptions(request: RebootDesktopsRequest, runtime: $Util.RuntimeOptions): Promise<RebootDesktopsResponse>;
|
|
1715
|
+
rebootDesktops(request: RebootDesktopsRequest): Promise<RebootDesktopsResponse>;
|
|
1716
|
+
refreshLoginTokenWithOptions(request: RefreshLoginTokenRequest, runtime: $Util.RuntimeOptions): Promise<RefreshLoginTokenResponse>;
|
|
1717
|
+
refreshLoginToken(request: RefreshLoginTokenRequest): Promise<RefreshLoginTokenResponse>;
|
|
1718
|
+
reportEdsAgentInfoWithOptions(request: ReportEdsAgentInfoRequest, runtime: $Util.RuntimeOptions): Promise<ReportEdsAgentInfoResponse>;
|
|
1719
|
+
reportEdsAgentInfo(request: ReportEdsAgentInfoRequest): Promise<ReportEdsAgentInfoResponse>;
|
|
1720
|
+
reportSessionStatusWithOptions(request: ReportSessionStatusRequest, runtime: $Util.RuntimeOptions): Promise<ReportSessionStatusResponse>;
|
|
1721
|
+
reportSessionStatus(request: ReportSessionStatusRequest): Promise<ReportSessionStatusResponse>;
|
|
1722
|
+
resetPasswordWithOptions(request: ResetPasswordRequest, runtime: $Util.RuntimeOptions): Promise<ResetPasswordResponse>;
|
|
1723
|
+
resetPassword(request: ResetPasswordRequest): Promise<ResetPasswordResponse>;
|
|
1724
|
+
resetSnapshotWithOptions(request: ResetSnapshotRequest, runtime: $Util.RuntimeOptions): Promise<ResetSnapshotResponse>;
|
|
1725
|
+
resetSnapshot(request: ResetSnapshotRequest): Promise<ResetSnapshotResponse>;
|
|
1726
|
+
sendTokenCodeWithOptions(request: SendTokenCodeRequest, runtime: $Util.RuntimeOptions): Promise<SendTokenCodeResponse>;
|
|
1727
|
+
sendTokenCode(request: SendTokenCodeRequest): Promise<SendTokenCodeResponse>;
|
|
1728
|
+
setFingerPrintTemplateWithOptions(request: SetFingerPrintTemplateRequest, runtime: $Util.RuntimeOptions): Promise<SetFingerPrintTemplateResponse>;
|
|
1729
|
+
setFingerPrintTemplate(request: SetFingerPrintTemplateRequest): Promise<SetFingerPrintTemplateResponse>;
|
|
1730
|
+
setFingerPrintTemplateDescriptionWithOptions(request: SetFingerPrintTemplateDescriptionRequest, runtime: $Util.RuntimeOptions): Promise<SetFingerPrintTemplateDescriptionResponse>;
|
|
1731
|
+
setFingerPrintTemplateDescription(request: SetFingerPrintTemplateDescriptionRequest): Promise<SetFingerPrintTemplateDescriptionResponse>;
|
|
1732
|
+
/**
|
|
1733
|
+
* The ID of the client.
|
|
1734
|
+
*
|
|
1735
|
+
* @param request StartDesktopsRequest
|
|
1736
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
1737
|
+
* @return StartDesktopsResponse
|
|
1738
|
+
*/
|
|
1739
|
+
startDesktopsWithOptions(request: StartDesktopsRequest, runtime: $Util.RuntimeOptions): Promise<StartDesktopsResponse>;
|
|
1740
|
+
/**
|
|
1741
|
+
* The ID of the client.
|
|
1742
|
+
*
|
|
1743
|
+
* @param request StartDesktopsRequest
|
|
1744
|
+
* @return StartDesktopsResponse
|
|
1745
|
+
*/
|
|
1746
|
+
startDesktops(request: StartDesktopsRequest): Promise<StartDesktopsResponse>;
|
|
1747
|
+
startRecordContentWithOptions(request: StartRecordContentRequest, runtime: $Util.RuntimeOptions): Promise<StartRecordContentResponse>;
|
|
1748
|
+
startRecordContent(request: StartRecordContentRequest): Promise<StartRecordContentResponse>;
|
|
1749
|
+
/**
|
|
1750
|
+
* The cloud desktops that you want to stop by calling this operation must be in the Running state. If the call is successful, the cloud desktops enter the Stopped state.
|
|
1751
|
+
*
|
|
1752
|
+
* @param request StopDesktopsRequest
|
|
1753
|
+
* @param runtime runtime options for this request RuntimeOptions
|
|
1754
|
+
* @return StopDesktopsResponse
|
|
1755
|
+
*/
|
|
1756
|
+
stopDesktopsWithOptions(request: StopDesktopsRequest, runtime: $Util.RuntimeOptions): Promise<StopDesktopsResponse>;
|
|
1757
|
+
/**
|
|
1758
|
+
* The cloud desktops that you want to stop by calling this operation must be in the Running state. If the call is successful, the cloud desktops enter the Stopped state.
|
|
1759
|
+
*
|
|
1760
|
+
* @param request StopDesktopsRequest
|
|
1761
|
+
* @return StopDesktopsResponse
|
|
1762
|
+
*/
|
|
1763
|
+
stopDesktops(request: StopDesktopsRequest): Promise<StopDesktopsResponse>;
|
|
1764
|
+
stopRecordContentWithOptions(request: StopRecordContentRequest, runtime: $Util.RuntimeOptions): Promise<StopRecordContentResponse>;
|
|
1765
|
+
stopRecordContent(request: StopRecordContentRequest): Promise<StopRecordContentResponse>;
|
|
1766
|
+
unbindUserDesktopWithOptions(request: UnbindUserDesktopRequest, runtime: $Util.RuntimeOptions): Promise<UnbindUserDesktopResponse>;
|
|
1767
|
+
unbindUserDesktop(request: UnbindUserDesktopRequest): Promise<UnbindUserDesktopResponse>;
|
|
1768
|
+
verifyCredentialWithOptions(request: VerifyCredentialRequest, runtime: $Util.RuntimeOptions): Promise<VerifyCredentialResponse>;
|
|
1769
|
+
verifyCredential(request: VerifyCredentialRequest): Promise<VerifyCredentialResponse>;
|
|
255
1770
|
}
|