@alicloud/aimiaobi20230801 1.0.0 → 1.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/dist/client.d.ts +2101 -4
- package/dist/client.js +4140 -45
- package/dist/client.js.map +1 -1
- package/package.json +1 -1
- package/src/client.ts +5247 -47
package/dist/client.d.ts
CHANGED
|
@@ -4,6 +4,125 @@
|
|
|
4
4
|
import * as $Util from '@alicloud/tea-util';
|
|
5
5
|
import OpenApi, * as $OpenApi from '@alicloud/openapi-client';
|
|
6
6
|
import * as $tea from '@alicloud/tea-typescript';
|
|
7
|
+
export declare class CancelAsyncTaskRequest extends $tea.Model {
|
|
8
|
+
agentKey?: string;
|
|
9
|
+
taskId?: string;
|
|
10
|
+
static names(): {
|
|
11
|
+
[key: string]: string;
|
|
12
|
+
};
|
|
13
|
+
static types(): {
|
|
14
|
+
[key: string]: any;
|
|
15
|
+
};
|
|
16
|
+
constructor(map?: {
|
|
17
|
+
[key: string]: any;
|
|
18
|
+
});
|
|
19
|
+
}
|
|
20
|
+
export declare class CancelAsyncTaskResponseBody extends $tea.Model {
|
|
21
|
+
code?: string;
|
|
22
|
+
data?: boolean;
|
|
23
|
+
httpStatusCode?: number;
|
|
24
|
+
message?: string;
|
|
25
|
+
requestId?: string;
|
|
26
|
+
success?: boolean;
|
|
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 CancelAsyncTaskResponse extends $tea.Model {
|
|
38
|
+
headers: {
|
|
39
|
+
[key: string]: string;
|
|
40
|
+
};
|
|
41
|
+
statusCode: number;
|
|
42
|
+
body: CancelAsyncTaskResponseBody;
|
|
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 CreateGeneratedContentRequest extends $tea.Model {
|
|
54
|
+
agentKey?: string;
|
|
55
|
+
content?: string;
|
|
56
|
+
contentDomain?: string;
|
|
57
|
+
contentText?: string;
|
|
58
|
+
keywords?: string[];
|
|
59
|
+
prompt?: string;
|
|
60
|
+
taskId?: string;
|
|
61
|
+
title?: string;
|
|
62
|
+
uuid?: string;
|
|
63
|
+
static names(): {
|
|
64
|
+
[key: string]: string;
|
|
65
|
+
};
|
|
66
|
+
static types(): {
|
|
67
|
+
[key: string]: any;
|
|
68
|
+
};
|
|
69
|
+
constructor(map?: {
|
|
70
|
+
[key: string]: any;
|
|
71
|
+
});
|
|
72
|
+
}
|
|
73
|
+
export declare class CreateGeneratedContentShrinkRequest extends $tea.Model {
|
|
74
|
+
agentKey?: string;
|
|
75
|
+
content?: string;
|
|
76
|
+
contentDomain?: string;
|
|
77
|
+
contentText?: string;
|
|
78
|
+
keywordsShrink?: string;
|
|
79
|
+
prompt?: string;
|
|
80
|
+
taskId?: string;
|
|
81
|
+
title?: string;
|
|
82
|
+
uuid?: string;
|
|
83
|
+
static names(): {
|
|
84
|
+
[key: string]: string;
|
|
85
|
+
};
|
|
86
|
+
static types(): {
|
|
87
|
+
[key: string]: any;
|
|
88
|
+
};
|
|
89
|
+
constructor(map?: {
|
|
90
|
+
[key: string]: any;
|
|
91
|
+
});
|
|
92
|
+
}
|
|
93
|
+
export declare class CreateGeneratedContentResponseBody extends $tea.Model {
|
|
94
|
+
code?: string;
|
|
95
|
+
data?: number;
|
|
96
|
+
httpStatusCode?: number;
|
|
97
|
+
message?: string;
|
|
98
|
+
requestId?: string;
|
|
99
|
+
success?: boolean;
|
|
100
|
+
static names(): {
|
|
101
|
+
[key: string]: string;
|
|
102
|
+
};
|
|
103
|
+
static types(): {
|
|
104
|
+
[key: string]: any;
|
|
105
|
+
};
|
|
106
|
+
constructor(map?: {
|
|
107
|
+
[key: string]: any;
|
|
108
|
+
});
|
|
109
|
+
}
|
|
110
|
+
export declare class CreateGeneratedContentResponse extends $tea.Model {
|
|
111
|
+
headers: {
|
|
112
|
+
[key: string]: string;
|
|
113
|
+
};
|
|
114
|
+
statusCode: number;
|
|
115
|
+
body: CreateGeneratedContentResponseBody;
|
|
116
|
+
static names(): {
|
|
117
|
+
[key: string]: string;
|
|
118
|
+
};
|
|
119
|
+
static types(): {
|
|
120
|
+
[key: string]: any;
|
|
121
|
+
};
|
|
122
|
+
constructor(map?: {
|
|
123
|
+
[key: string]: any;
|
|
124
|
+
});
|
|
125
|
+
}
|
|
7
126
|
export declare class CreateTokenRequest extends $tea.Model {
|
|
8
127
|
agentKey?: string;
|
|
9
128
|
static names(): {
|
|
@@ -19,7 +138,7 @@ export declare class CreateTokenRequest extends $tea.Model {
|
|
|
19
138
|
export declare class CreateTokenResponseBody extends $tea.Model {
|
|
20
139
|
code?: string;
|
|
21
140
|
data?: CreateTokenResponseBodyData;
|
|
22
|
-
httpStatusCode?:
|
|
141
|
+
httpStatusCode?: number;
|
|
23
142
|
message?: string;
|
|
24
143
|
requestId?: string;
|
|
25
144
|
success?: boolean;
|
|
@@ -49,9 +168,1937 @@ export declare class CreateTokenResponse extends $tea.Model {
|
|
|
49
168
|
[key: string]: any;
|
|
50
169
|
});
|
|
51
170
|
}
|
|
52
|
-
export declare class
|
|
53
|
-
|
|
54
|
-
|
|
171
|
+
export declare class DeleteGeneratedContentRequest extends $tea.Model {
|
|
172
|
+
agentKey?: string;
|
|
173
|
+
id?: number;
|
|
174
|
+
static names(): {
|
|
175
|
+
[key: string]: string;
|
|
176
|
+
};
|
|
177
|
+
static types(): {
|
|
178
|
+
[key: string]: any;
|
|
179
|
+
};
|
|
180
|
+
constructor(map?: {
|
|
181
|
+
[key: string]: any;
|
|
182
|
+
});
|
|
183
|
+
}
|
|
184
|
+
export declare class DeleteGeneratedContentResponseBody extends $tea.Model {
|
|
185
|
+
code?: string;
|
|
186
|
+
data?: boolean;
|
|
187
|
+
httpStatusCode?: number;
|
|
188
|
+
message?: string;
|
|
189
|
+
requestId?: string;
|
|
190
|
+
success?: boolean;
|
|
191
|
+
static names(): {
|
|
192
|
+
[key: string]: string;
|
|
193
|
+
};
|
|
194
|
+
static types(): {
|
|
195
|
+
[key: string]: any;
|
|
196
|
+
};
|
|
197
|
+
constructor(map?: {
|
|
198
|
+
[key: string]: any;
|
|
199
|
+
});
|
|
200
|
+
}
|
|
201
|
+
export declare class DeleteGeneratedContentResponse extends $tea.Model {
|
|
202
|
+
headers: {
|
|
203
|
+
[key: string]: string;
|
|
204
|
+
};
|
|
205
|
+
statusCode: number;
|
|
206
|
+
body: DeleteGeneratedContentResponseBody;
|
|
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 DeleteMaterialByIdRequest extends $tea.Model {
|
|
218
|
+
agentKey?: string;
|
|
219
|
+
id?: number;
|
|
220
|
+
static names(): {
|
|
221
|
+
[key: string]: string;
|
|
222
|
+
};
|
|
223
|
+
static types(): {
|
|
224
|
+
[key: string]: any;
|
|
225
|
+
};
|
|
226
|
+
constructor(map?: {
|
|
227
|
+
[key: string]: any;
|
|
228
|
+
});
|
|
229
|
+
}
|
|
230
|
+
export declare class DeleteMaterialByIdResponseBody extends $tea.Model {
|
|
231
|
+
code?: string;
|
|
232
|
+
data?: boolean;
|
|
233
|
+
httpStatusCode?: number;
|
|
234
|
+
message?: string;
|
|
235
|
+
requestId?: string;
|
|
236
|
+
success?: boolean;
|
|
237
|
+
static names(): {
|
|
238
|
+
[key: string]: string;
|
|
239
|
+
};
|
|
240
|
+
static types(): {
|
|
241
|
+
[key: string]: any;
|
|
242
|
+
};
|
|
243
|
+
constructor(map?: {
|
|
244
|
+
[key: string]: any;
|
|
245
|
+
});
|
|
246
|
+
}
|
|
247
|
+
export declare class DeleteMaterialByIdResponse extends $tea.Model {
|
|
248
|
+
headers: {
|
|
249
|
+
[key: string]: string;
|
|
250
|
+
};
|
|
251
|
+
statusCode: number;
|
|
252
|
+
body: DeleteMaterialByIdResponseBody;
|
|
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 ExportGeneratedContentRequest extends $tea.Model {
|
|
264
|
+
agentKey?: string;
|
|
265
|
+
id?: number;
|
|
266
|
+
static names(): {
|
|
267
|
+
[key: string]: string;
|
|
268
|
+
};
|
|
269
|
+
static types(): {
|
|
270
|
+
[key: string]: any;
|
|
271
|
+
};
|
|
272
|
+
constructor(map?: {
|
|
273
|
+
[key: string]: any;
|
|
274
|
+
});
|
|
275
|
+
}
|
|
276
|
+
export declare class ExportGeneratedContentResponseBody extends $tea.Model {
|
|
277
|
+
code?: string;
|
|
278
|
+
data?: string;
|
|
279
|
+
httpStatusCode?: number;
|
|
280
|
+
message?: string;
|
|
281
|
+
requestId?: string;
|
|
282
|
+
success?: boolean;
|
|
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 ExportGeneratedContentResponse extends $tea.Model {
|
|
294
|
+
headers: {
|
|
295
|
+
[key: string]: string;
|
|
296
|
+
};
|
|
297
|
+
statusCode: number;
|
|
298
|
+
body: ExportGeneratedContentResponseBody;
|
|
299
|
+
static names(): {
|
|
300
|
+
[key: string]: string;
|
|
301
|
+
};
|
|
302
|
+
static types(): {
|
|
303
|
+
[key: string]: any;
|
|
304
|
+
};
|
|
305
|
+
constructor(map?: {
|
|
306
|
+
[key: string]: any;
|
|
307
|
+
});
|
|
308
|
+
}
|
|
309
|
+
export declare class FeedbackDialogueRequest extends $tea.Model {
|
|
310
|
+
agentKey?: string;
|
|
311
|
+
customerResponse?: string;
|
|
312
|
+
goodText?: string;
|
|
313
|
+
modifiedResponse?: string;
|
|
314
|
+
rating?: string;
|
|
315
|
+
ratingTags?: string[];
|
|
316
|
+
sessionId?: string;
|
|
317
|
+
taskId?: string;
|
|
318
|
+
static names(): {
|
|
319
|
+
[key: string]: string;
|
|
320
|
+
};
|
|
321
|
+
static types(): {
|
|
322
|
+
[key: string]: any;
|
|
323
|
+
};
|
|
324
|
+
constructor(map?: {
|
|
325
|
+
[key: string]: any;
|
|
326
|
+
});
|
|
327
|
+
}
|
|
328
|
+
export declare class FeedbackDialogueShrinkRequest extends $tea.Model {
|
|
329
|
+
agentKey?: string;
|
|
330
|
+
customerResponse?: string;
|
|
331
|
+
goodText?: string;
|
|
332
|
+
modifiedResponse?: string;
|
|
333
|
+
rating?: string;
|
|
334
|
+
ratingTagsShrink?: string;
|
|
335
|
+
sessionId?: string;
|
|
336
|
+
taskId?: string;
|
|
337
|
+
static names(): {
|
|
338
|
+
[key: string]: string;
|
|
339
|
+
};
|
|
340
|
+
static types(): {
|
|
341
|
+
[key: string]: any;
|
|
342
|
+
};
|
|
343
|
+
constructor(map?: {
|
|
344
|
+
[key: string]: any;
|
|
345
|
+
});
|
|
346
|
+
}
|
|
347
|
+
export declare class FeedbackDialogueResponseBody extends $tea.Model {
|
|
348
|
+
code?: string;
|
|
349
|
+
httpStatusCode?: number;
|
|
350
|
+
message?: string;
|
|
351
|
+
requestId?: string;
|
|
352
|
+
success?: boolean;
|
|
353
|
+
static names(): {
|
|
354
|
+
[key: string]: string;
|
|
355
|
+
};
|
|
356
|
+
static types(): {
|
|
357
|
+
[key: string]: any;
|
|
358
|
+
};
|
|
359
|
+
constructor(map?: {
|
|
360
|
+
[key: string]: any;
|
|
361
|
+
});
|
|
362
|
+
}
|
|
363
|
+
export declare class FeedbackDialogueResponse extends $tea.Model {
|
|
364
|
+
headers: {
|
|
365
|
+
[key: string]: string;
|
|
366
|
+
};
|
|
367
|
+
statusCode: number;
|
|
368
|
+
body: FeedbackDialogueResponseBody;
|
|
369
|
+
static names(): {
|
|
370
|
+
[key: string]: string;
|
|
371
|
+
};
|
|
372
|
+
static types(): {
|
|
373
|
+
[key: string]: any;
|
|
374
|
+
};
|
|
375
|
+
constructor(map?: {
|
|
376
|
+
[key: string]: any;
|
|
377
|
+
});
|
|
378
|
+
}
|
|
379
|
+
export declare class FetchImageTaskRequest extends $tea.Model {
|
|
380
|
+
agentKey?: string;
|
|
381
|
+
articleTaskId?: string;
|
|
382
|
+
taskIdList?: string[];
|
|
383
|
+
static names(): {
|
|
384
|
+
[key: string]: string;
|
|
385
|
+
};
|
|
386
|
+
static types(): {
|
|
387
|
+
[key: string]: any;
|
|
388
|
+
};
|
|
389
|
+
constructor(map?: {
|
|
390
|
+
[key: string]: any;
|
|
391
|
+
});
|
|
392
|
+
}
|
|
393
|
+
export declare class FetchImageTaskShrinkRequest extends $tea.Model {
|
|
394
|
+
agentKey?: string;
|
|
395
|
+
articleTaskId?: string;
|
|
396
|
+
taskIdListShrink?: string;
|
|
397
|
+
static names(): {
|
|
398
|
+
[key: string]: string;
|
|
399
|
+
};
|
|
400
|
+
static types(): {
|
|
401
|
+
[key: string]: any;
|
|
402
|
+
};
|
|
403
|
+
constructor(map?: {
|
|
404
|
+
[key: string]: any;
|
|
405
|
+
});
|
|
406
|
+
}
|
|
407
|
+
export declare class FetchImageTaskResponseBody extends $tea.Model {
|
|
408
|
+
code?: string;
|
|
409
|
+
data?: FetchImageTaskResponseBodyData;
|
|
410
|
+
httpStatusCode?: number;
|
|
411
|
+
message?: string;
|
|
412
|
+
requestId?: string;
|
|
413
|
+
success?: boolean;
|
|
414
|
+
static names(): {
|
|
415
|
+
[key: string]: string;
|
|
416
|
+
};
|
|
417
|
+
static types(): {
|
|
418
|
+
[key: string]: any;
|
|
419
|
+
};
|
|
420
|
+
constructor(map?: {
|
|
421
|
+
[key: string]: any;
|
|
422
|
+
});
|
|
423
|
+
}
|
|
424
|
+
export declare class FetchImageTaskResponse extends $tea.Model {
|
|
425
|
+
headers: {
|
|
426
|
+
[key: string]: string;
|
|
427
|
+
};
|
|
428
|
+
statusCode: number;
|
|
429
|
+
body: FetchImageTaskResponseBody;
|
|
430
|
+
static names(): {
|
|
431
|
+
[key: string]: string;
|
|
432
|
+
};
|
|
433
|
+
static types(): {
|
|
434
|
+
[key: string]: any;
|
|
435
|
+
};
|
|
436
|
+
constructor(map?: {
|
|
437
|
+
[key: string]: any;
|
|
438
|
+
});
|
|
439
|
+
}
|
|
440
|
+
export declare class GenerateImageTaskRequest extends $tea.Model {
|
|
441
|
+
agentKey?: string;
|
|
442
|
+
articleTaskId?: string;
|
|
443
|
+
paragraphList?: GenerateImageTaskRequestParagraphList[];
|
|
444
|
+
size?: string;
|
|
445
|
+
style?: string;
|
|
446
|
+
static names(): {
|
|
447
|
+
[key: string]: string;
|
|
448
|
+
};
|
|
449
|
+
static types(): {
|
|
450
|
+
[key: string]: any;
|
|
451
|
+
};
|
|
452
|
+
constructor(map?: {
|
|
453
|
+
[key: string]: any;
|
|
454
|
+
});
|
|
455
|
+
}
|
|
456
|
+
export declare class GenerateImageTaskShrinkRequest extends $tea.Model {
|
|
457
|
+
agentKey?: string;
|
|
458
|
+
articleTaskId?: string;
|
|
459
|
+
paragraphListShrink?: string;
|
|
460
|
+
size?: string;
|
|
461
|
+
style?: string;
|
|
462
|
+
static names(): {
|
|
463
|
+
[key: string]: string;
|
|
464
|
+
};
|
|
465
|
+
static types(): {
|
|
466
|
+
[key: string]: any;
|
|
467
|
+
};
|
|
468
|
+
constructor(map?: {
|
|
469
|
+
[key: string]: any;
|
|
470
|
+
});
|
|
471
|
+
}
|
|
472
|
+
export declare class GenerateImageTaskResponseBody extends $tea.Model {
|
|
473
|
+
code?: string;
|
|
474
|
+
data?: GenerateImageTaskResponseBodyData;
|
|
475
|
+
httpStatusCode?: number;
|
|
476
|
+
message?: string;
|
|
477
|
+
requestId?: string;
|
|
478
|
+
success?: boolean;
|
|
479
|
+
static names(): {
|
|
480
|
+
[key: string]: string;
|
|
481
|
+
};
|
|
482
|
+
static types(): {
|
|
483
|
+
[key: string]: any;
|
|
484
|
+
};
|
|
485
|
+
constructor(map?: {
|
|
486
|
+
[key: string]: any;
|
|
487
|
+
});
|
|
488
|
+
}
|
|
489
|
+
export declare class GenerateImageTaskResponse extends $tea.Model {
|
|
490
|
+
headers: {
|
|
491
|
+
[key: string]: string;
|
|
492
|
+
};
|
|
493
|
+
statusCode: number;
|
|
494
|
+
body: GenerateImageTaskResponseBody;
|
|
495
|
+
static names(): {
|
|
496
|
+
[key: string]: string;
|
|
497
|
+
};
|
|
498
|
+
static types(): {
|
|
499
|
+
[key: string]: any;
|
|
500
|
+
};
|
|
501
|
+
constructor(map?: {
|
|
502
|
+
[key: string]: any;
|
|
503
|
+
});
|
|
504
|
+
}
|
|
505
|
+
export declare class GenerateViewPointRequest extends $tea.Model {
|
|
506
|
+
agentKey?: string;
|
|
507
|
+
referenceData?: GenerateViewPointRequestReferenceData;
|
|
508
|
+
static names(): {
|
|
509
|
+
[key: string]: string;
|
|
510
|
+
};
|
|
511
|
+
static types(): {
|
|
512
|
+
[key: string]: any;
|
|
513
|
+
};
|
|
514
|
+
constructor(map?: {
|
|
515
|
+
[key: string]: any;
|
|
516
|
+
});
|
|
517
|
+
}
|
|
518
|
+
export declare class GenerateViewPointShrinkRequest extends $tea.Model {
|
|
519
|
+
agentKey?: string;
|
|
520
|
+
referenceDataShrink?: string;
|
|
521
|
+
static names(): {
|
|
522
|
+
[key: string]: string;
|
|
523
|
+
};
|
|
524
|
+
static types(): {
|
|
525
|
+
[key: string]: any;
|
|
526
|
+
};
|
|
527
|
+
constructor(map?: {
|
|
528
|
+
[key: string]: any;
|
|
529
|
+
});
|
|
530
|
+
}
|
|
531
|
+
export declare class GenerateViewPointResponseBody extends $tea.Model {
|
|
532
|
+
code?: string;
|
|
533
|
+
data?: GenerateViewPointResponseBodyData[];
|
|
534
|
+
httpStatusCode?: number;
|
|
535
|
+
message?: string;
|
|
536
|
+
requestId?: string;
|
|
537
|
+
success?: boolean;
|
|
538
|
+
static names(): {
|
|
539
|
+
[key: string]: string;
|
|
540
|
+
};
|
|
541
|
+
static types(): {
|
|
542
|
+
[key: string]: any;
|
|
543
|
+
};
|
|
544
|
+
constructor(map?: {
|
|
545
|
+
[key: string]: any;
|
|
546
|
+
});
|
|
547
|
+
}
|
|
548
|
+
export declare class GenerateViewPointResponse extends $tea.Model {
|
|
549
|
+
headers: {
|
|
550
|
+
[key: string]: string;
|
|
551
|
+
};
|
|
552
|
+
statusCode: number;
|
|
553
|
+
body: GenerateViewPointResponseBody;
|
|
554
|
+
static names(): {
|
|
555
|
+
[key: string]: string;
|
|
556
|
+
};
|
|
557
|
+
static types(): {
|
|
558
|
+
[key: string]: any;
|
|
559
|
+
};
|
|
560
|
+
constructor(map?: {
|
|
561
|
+
[key: string]: any;
|
|
562
|
+
});
|
|
563
|
+
}
|
|
564
|
+
export declare class GetDataSourceOrderConfigRequest extends $tea.Model {
|
|
565
|
+
agentKey?: string;
|
|
566
|
+
productCode?: string;
|
|
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 GetDataSourceOrderConfigResponseBody extends $tea.Model {
|
|
578
|
+
code?: string;
|
|
579
|
+
data?: GetDataSourceOrderConfigResponseBodyData;
|
|
580
|
+
httpStatusCode?: number;
|
|
581
|
+
message?: string;
|
|
582
|
+
requestId?: string;
|
|
583
|
+
success?: boolean;
|
|
584
|
+
static names(): {
|
|
585
|
+
[key: string]: string;
|
|
586
|
+
};
|
|
587
|
+
static types(): {
|
|
588
|
+
[key: string]: any;
|
|
589
|
+
};
|
|
590
|
+
constructor(map?: {
|
|
591
|
+
[key: string]: any;
|
|
592
|
+
});
|
|
593
|
+
}
|
|
594
|
+
export declare class GetDataSourceOrderConfigResponse extends $tea.Model {
|
|
595
|
+
headers: {
|
|
596
|
+
[key: string]: string;
|
|
597
|
+
};
|
|
598
|
+
statusCode: number;
|
|
599
|
+
body: GetDataSourceOrderConfigResponseBody;
|
|
600
|
+
static names(): {
|
|
601
|
+
[key: string]: string;
|
|
602
|
+
};
|
|
603
|
+
static types(): {
|
|
604
|
+
[key: string]: any;
|
|
605
|
+
};
|
|
606
|
+
constructor(map?: {
|
|
607
|
+
[key: string]: any;
|
|
608
|
+
});
|
|
609
|
+
}
|
|
610
|
+
export declare class GetGeneratedContentRequest extends $tea.Model {
|
|
611
|
+
agentKey?: string;
|
|
612
|
+
id?: number;
|
|
613
|
+
static names(): {
|
|
614
|
+
[key: string]: string;
|
|
615
|
+
};
|
|
616
|
+
static types(): {
|
|
617
|
+
[key: string]: any;
|
|
618
|
+
};
|
|
619
|
+
constructor(map?: {
|
|
620
|
+
[key: string]: any;
|
|
621
|
+
});
|
|
622
|
+
}
|
|
623
|
+
export declare class GetGeneratedContentResponseBody extends $tea.Model {
|
|
624
|
+
code?: string;
|
|
625
|
+
data?: GetGeneratedContentResponseBodyData;
|
|
626
|
+
httpStatusCode?: number;
|
|
627
|
+
message?: string;
|
|
628
|
+
requestId?: string;
|
|
629
|
+
success?: boolean;
|
|
630
|
+
static names(): {
|
|
631
|
+
[key: string]: string;
|
|
632
|
+
};
|
|
633
|
+
static types(): {
|
|
634
|
+
[key: string]: any;
|
|
635
|
+
};
|
|
636
|
+
constructor(map?: {
|
|
637
|
+
[key: string]: any;
|
|
638
|
+
});
|
|
639
|
+
}
|
|
640
|
+
export declare class GetGeneratedContentResponse extends $tea.Model {
|
|
641
|
+
headers: {
|
|
642
|
+
[key: string]: string;
|
|
643
|
+
};
|
|
644
|
+
statusCode: number;
|
|
645
|
+
body: GetGeneratedContentResponseBody;
|
|
646
|
+
static names(): {
|
|
647
|
+
[key: string]: string;
|
|
648
|
+
};
|
|
649
|
+
static types(): {
|
|
650
|
+
[key: string]: any;
|
|
651
|
+
};
|
|
652
|
+
constructor(map?: {
|
|
653
|
+
[key: string]: any;
|
|
654
|
+
});
|
|
655
|
+
}
|
|
656
|
+
export declare class GetMaterialByIdRequest extends $tea.Model {
|
|
657
|
+
agentKey?: string;
|
|
658
|
+
id?: number;
|
|
659
|
+
static names(): {
|
|
660
|
+
[key: string]: string;
|
|
661
|
+
};
|
|
662
|
+
static types(): {
|
|
663
|
+
[key: string]: any;
|
|
664
|
+
};
|
|
665
|
+
constructor(map?: {
|
|
666
|
+
[key: string]: any;
|
|
667
|
+
});
|
|
668
|
+
}
|
|
669
|
+
export declare class GetMaterialByIdResponseBody extends $tea.Model {
|
|
670
|
+
code?: string;
|
|
671
|
+
data?: GetMaterialByIdResponseBodyData;
|
|
672
|
+
httpStatusCode?: number;
|
|
673
|
+
message?: string;
|
|
674
|
+
requestId?: string;
|
|
675
|
+
success?: boolean;
|
|
676
|
+
static names(): {
|
|
677
|
+
[key: string]: string;
|
|
678
|
+
};
|
|
679
|
+
static types(): {
|
|
680
|
+
[key: string]: any;
|
|
681
|
+
};
|
|
682
|
+
constructor(map?: {
|
|
683
|
+
[key: string]: any;
|
|
684
|
+
});
|
|
685
|
+
}
|
|
686
|
+
export declare class GetMaterialByIdResponse extends $tea.Model {
|
|
687
|
+
headers: {
|
|
688
|
+
[key: string]: string;
|
|
689
|
+
};
|
|
690
|
+
statusCode: number;
|
|
691
|
+
body: GetMaterialByIdResponseBody;
|
|
692
|
+
static names(): {
|
|
693
|
+
[key: string]: string;
|
|
694
|
+
};
|
|
695
|
+
static types(): {
|
|
696
|
+
[key: string]: any;
|
|
697
|
+
};
|
|
698
|
+
constructor(map?: {
|
|
699
|
+
[key: string]: any;
|
|
700
|
+
});
|
|
701
|
+
}
|
|
702
|
+
export declare class GetPropertiesRequest extends $tea.Model {
|
|
703
|
+
agentKey?: string;
|
|
704
|
+
static names(): {
|
|
705
|
+
[key: string]: string;
|
|
706
|
+
};
|
|
707
|
+
static types(): {
|
|
708
|
+
[key: string]: any;
|
|
709
|
+
};
|
|
710
|
+
constructor(map?: {
|
|
711
|
+
[key: string]: any;
|
|
712
|
+
});
|
|
713
|
+
}
|
|
714
|
+
export declare class GetPropertiesResponseBody extends $tea.Model {
|
|
715
|
+
code?: string;
|
|
716
|
+
data?: GetPropertiesResponseBodyData;
|
|
717
|
+
httpStatusCode?: number;
|
|
718
|
+
message?: string;
|
|
719
|
+
requestId?: string;
|
|
720
|
+
success?: boolean;
|
|
721
|
+
static names(): {
|
|
722
|
+
[key: string]: string;
|
|
723
|
+
};
|
|
724
|
+
static types(): {
|
|
725
|
+
[key: string]: any;
|
|
726
|
+
};
|
|
727
|
+
constructor(map?: {
|
|
728
|
+
[key: string]: any;
|
|
729
|
+
});
|
|
730
|
+
}
|
|
731
|
+
export declare class GetPropertiesResponse extends $tea.Model {
|
|
732
|
+
headers: {
|
|
733
|
+
[key: string]: string;
|
|
734
|
+
};
|
|
735
|
+
statusCode: number;
|
|
736
|
+
body: GetPropertiesResponseBody;
|
|
737
|
+
static names(): {
|
|
738
|
+
[key: string]: string;
|
|
739
|
+
};
|
|
740
|
+
static types(): {
|
|
741
|
+
[key: string]: any;
|
|
742
|
+
};
|
|
743
|
+
constructor(map?: {
|
|
744
|
+
[key: string]: any;
|
|
745
|
+
});
|
|
746
|
+
}
|
|
747
|
+
export declare class ListAsyncTasksRequest extends $tea.Model {
|
|
748
|
+
agentKey?: string;
|
|
749
|
+
createTimeEnd?: string;
|
|
750
|
+
createTimeStart?: string;
|
|
751
|
+
current?: number;
|
|
752
|
+
size?: number;
|
|
753
|
+
taskCode?: string;
|
|
754
|
+
taskName?: string;
|
|
755
|
+
taskStatus?: number;
|
|
756
|
+
taskStatusList?: number[];
|
|
757
|
+
taskType?: string;
|
|
758
|
+
taskTypeList?: string[];
|
|
759
|
+
static names(): {
|
|
760
|
+
[key: string]: string;
|
|
761
|
+
};
|
|
762
|
+
static types(): {
|
|
763
|
+
[key: string]: any;
|
|
764
|
+
};
|
|
765
|
+
constructor(map?: {
|
|
766
|
+
[key: string]: any;
|
|
767
|
+
});
|
|
768
|
+
}
|
|
769
|
+
export declare class ListAsyncTasksShrinkRequest extends $tea.Model {
|
|
770
|
+
agentKey?: string;
|
|
771
|
+
createTimeEnd?: string;
|
|
772
|
+
createTimeStart?: string;
|
|
773
|
+
current?: number;
|
|
774
|
+
size?: number;
|
|
775
|
+
taskCode?: string;
|
|
776
|
+
taskName?: string;
|
|
777
|
+
taskStatus?: number;
|
|
778
|
+
taskStatusListShrink?: string;
|
|
779
|
+
taskType?: string;
|
|
780
|
+
taskTypeListShrink?: string;
|
|
781
|
+
static names(): {
|
|
782
|
+
[key: string]: string;
|
|
783
|
+
};
|
|
784
|
+
static types(): {
|
|
785
|
+
[key: string]: any;
|
|
786
|
+
};
|
|
787
|
+
constructor(map?: {
|
|
788
|
+
[key: string]: any;
|
|
789
|
+
});
|
|
790
|
+
}
|
|
791
|
+
export declare class ListAsyncTasksResponseBody extends $tea.Model {
|
|
792
|
+
code?: string;
|
|
793
|
+
current?: number;
|
|
794
|
+
data?: ListAsyncTasksResponseBodyData[];
|
|
795
|
+
httpStatusCode?: number;
|
|
796
|
+
message?: string;
|
|
797
|
+
requestId?: string;
|
|
798
|
+
size?: number;
|
|
799
|
+
success?: boolean;
|
|
800
|
+
total?: number;
|
|
801
|
+
static names(): {
|
|
802
|
+
[key: string]: string;
|
|
803
|
+
};
|
|
804
|
+
static types(): {
|
|
805
|
+
[key: string]: any;
|
|
806
|
+
};
|
|
807
|
+
constructor(map?: {
|
|
808
|
+
[key: string]: any;
|
|
809
|
+
});
|
|
810
|
+
}
|
|
811
|
+
export declare class ListAsyncTasksResponse extends $tea.Model {
|
|
812
|
+
headers: {
|
|
813
|
+
[key: string]: string;
|
|
814
|
+
};
|
|
815
|
+
statusCode: number;
|
|
816
|
+
body: ListAsyncTasksResponseBody;
|
|
817
|
+
static names(): {
|
|
818
|
+
[key: string]: string;
|
|
819
|
+
};
|
|
820
|
+
static types(): {
|
|
821
|
+
[key: string]: any;
|
|
822
|
+
};
|
|
823
|
+
constructor(map?: {
|
|
824
|
+
[key: string]: any;
|
|
825
|
+
});
|
|
826
|
+
}
|
|
827
|
+
export declare class ListBuildConfigsRequest extends $tea.Model {
|
|
828
|
+
agentKey?: string;
|
|
829
|
+
type?: string;
|
|
830
|
+
static names(): {
|
|
831
|
+
[key: string]: string;
|
|
832
|
+
};
|
|
833
|
+
static types(): {
|
|
834
|
+
[key: string]: any;
|
|
835
|
+
};
|
|
836
|
+
constructor(map?: {
|
|
837
|
+
[key: string]: any;
|
|
838
|
+
});
|
|
839
|
+
}
|
|
840
|
+
export declare class ListBuildConfigsResponseBody extends $tea.Model {
|
|
841
|
+
code?: string;
|
|
842
|
+
data?: ListBuildConfigsResponseBodyData[];
|
|
843
|
+
httpStatusCode?: number;
|
|
844
|
+
message?: string;
|
|
845
|
+
requestId?: string;
|
|
846
|
+
success?: boolean;
|
|
847
|
+
static names(): {
|
|
848
|
+
[key: string]: string;
|
|
849
|
+
};
|
|
850
|
+
static types(): {
|
|
851
|
+
[key: string]: any;
|
|
852
|
+
};
|
|
853
|
+
constructor(map?: {
|
|
854
|
+
[key: string]: any;
|
|
855
|
+
});
|
|
856
|
+
}
|
|
857
|
+
export declare class ListBuildConfigsResponse extends $tea.Model {
|
|
858
|
+
headers: {
|
|
859
|
+
[key: string]: string;
|
|
860
|
+
};
|
|
861
|
+
statusCode: number;
|
|
862
|
+
body: ListBuildConfigsResponseBody;
|
|
863
|
+
static names(): {
|
|
864
|
+
[key: string]: string;
|
|
865
|
+
};
|
|
866
|
+
static types(): {
|
|
867
|
+
[key: string]: any;
|
|
868
|
+
};
|
|
869
|
+
constructor(map?: {
|
|
870
|
+
[key: string]: any;
|
|
871
|
+
});
|
|
872
|
+
}
|
|
873
|
+
export declare class ListDialoguesRequest extends $tea.Model {
|
|
874
|
+
agentKey?: string;
|
|
875
|
+
current?: number;
|
|
876
|
+
dialogueType?: number;
|
|
877
|
+
endTime?: string;
|
|
878
|
+
size?: number;
|
|
879
|
+
startTime?: string;
|
|
880
|
+
taskId?: string;
|
|
881
|
+
static names(): {
|
|
882
|
+
[key: string]: string;
|
|
883
|
+
};
|
|
884
|
+
static types(): {
|
|
885
|
+
[key: string]: any;
|
|
886
|
+
};
|
|
887
|
+
constructor(map?: {
|
|
888
|
+
[key: string]: any;
|
|
889
|
+
});
|
|
890
|
+
}
|
|
891
|
+
export declare class ListDialoguesResponseBody extends $tea.Model {
|
|
892
|
+
code?: string;
|
|
893
|
+
current?: number;
|
|
894
|
+
data?: ListDialoguesResponseBodyData[];
|
|
895
|
+
httpStatusCode?: number;
|
|
896
|
+
message?: string;
|
|
897
|
+
requestId?: string;
|
|
898
|
+
size?: number;
|
|
899
|
+
success?: boolean;
|
|
900
|
+
total?: number;
|
|
901
|
+
static names(): {
|
|
902
|
+
[key: string]: string;
|
|
903
|
+
};
|
|
904
|
+
static types(): {
|
|
905
|
+
[key: string]: any;
|
|
906
|
+
};
|
|
907
|
+
constructor(map?: {
|
|
908
|
+
[key: string]: any;
|
|
909
|
+
});
|
|
910
|
+
}
|
|
911
|
+
export declare class ListDialoguesResponse extends $tea.Model {
|
|
912
|
+
headers: {
|
|
913
|
+
[key: string]: string;
|
|
914
|
+
};
|
|
915
|
+
statusCode: number;
|
|
916
|
+
body: ListDialoguesResponseBody;
|
|
917
|
+
static names(): {
|
|
918
|
+
[key: string]: string;
|
|
919
|
+
};
|
|
920
|
+
static types(): {
|
|
921
|
+
[key: string]: any;
|
|
922
|
+
};
|
|
923
|
+
constructor(map?: {
|
|
924
|
+
[key: string]: any;
|
|
925
|
+
});
|
|
926
|
+
}
|
|
927
|
+
export declare class ListGeneratedContentsRequest extends $tea.Model {
|
|
928
|
+
agentKey?: string;
|
|
929
|
+
contentDomain?: string;
|
|
930
|
+
current?: number;
|
|
931
|
+
endTime?: string;
|
|
932
|
+
size?: number;
|
|
933
|
+
startTime?: string;
|
|
934
|
+
title?: string;
|
|
935
|
+
static names(): {
|
|
936
|
+
[key: string]: string;
|
|
937
|
+
};
|
|
938
|
+
static types(): {
|
|
939
|
+
[key: string]: any;
|
|
940
|
+
};
|
|
941
|
+
constructor(map?: {
|
|
942
|
+
[key: string]: any;
|
|
943
|
+
});
|
|
944
|
+
}
|
|
945
|
+
export declare class ListGeneratedContentsResponseBody extends $tea.Model {
|
|
946
|
+
code?: string;
|
|
947
|
+
current?: number;
|
|
948
|
+
data?: ListGeneratedContentsResponseBodyData[];
|
|
949
|
+
httpStatusCode?: number;
|
|
950
|
+
message?: string;
|
|
951
|
+
requestId?: string;
|
|
952
|
+
size?: number;
|
|
953
|
+
success?: boolean;
|
|
954
|
+
total?: number;
|
|
955
|
+
static names(): {
|
|
956
|
+
[key: string]: string;
|
|
957
|
+
};
|
|
958
|
+
static types(): {
|
|
959
|
+
[key: string]: any;
|
|
960
|
+
};
|
|
961
|
+
constructor(map?: {
|
|
962
|
+
[key: string]: any;
|
|
963
|
+
});
|
|
964
|
+
}
|
|
965
|
+
export declare class ListGeneratedContentsResponse extends $tea.Model {
|
|
966
|
+
headers: {
|
|
967
|
+
[key: string]: string;
|
|
968
|
+
};
|
|
969
|
+
statusCode: number;
|
|
970
|
+
body: ListGeneratedContentsResponseBody;
|
|
971
|
+
static names(): {
|
|
972
|
+
[key: string]: string;
|
|
973
|
+
};
|
|
974
|
+
static types(): {
|
|
975
|
+
[key: string]: any;
|
|
976
|
+
};
|
|
977
|
+
constructor(map?: {
|
|
978
|
+
[key: string]: any;
|
|
979
|
+
});
|
|
980
|
+
}
|
|
981
|
+
export declare class ListHotNewsWithTypeRequest extends $tea.Model {
|
|
982
|
+
agentKey?: string;
|
|
983
|
+
current?: number;
|
|
984
|
+
newsType?: string;
|
|
985
|
+
newsTypes?: string[];
|
|
986
|
+
size?: number;
|
|
987
|
+
static names(): {
|
|
988
|
+
[key: string]: string;
|
|
989
|
+
};
|
|
990
|
+
static types(): {
|
|
991
|
+
[key: string]: any;
|
|
992
|
+
};
|
|
993
|
+
constructor(map?: {
|
|
994
|
+
[key: string]: any;
|
|
995
|
+
});
|
|
996
|
+
}
|
|
997
|
+
export declare class ListHotNewsWithTypeShrinkRequest extends $tea.Model {
|
|
998
|
+
agentKey?: string;
|
|
999
|
+
current?: number;
|
|
1000
|
+
newsType?: string;
|
|
1001
|
+
newsTypesShrink?: string;
|
|
1002
|
+
size?: number;
|
|
1003
|
+
static names(): {
|
|
1004
|
+
[key: string]: string;
|
|
1005
|
+
};
|
|
1006
|
+
static types(): {
|
|
1007
|
+
[key: string]: any;
|
|
1008
|
+
};
|
|
1009
|
+
constructor(map?: {
|
|
1010
|
+
[key: string]: any;
|
|
1011
|
+
});
|
|
1012
|
+
}
|
|
1013
|
+
export declare class ListHotNewsWithTypeResponseBody extends $tea.Model {
|
|
1014
|
+
code?: string;
|
|
1015
|
+
data?: ListHotNewsWithTypeResponseBodyData[];
|
|
1016
|
+
httpStatusCode?: number;
|
|
1017
|
+
message?: string;
|
|
1018
|
+
requestId?: string;
|
|
1019
|
+
success?: boolean;
|
|
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 ListHotNewsWithTypeResponse extends $tea.Model {
|
|
1031
|
+
headers: {
|
|
1032
|
+
[key: string]: string;
|
|
1033
|
+
};
|
|
1034
|
+
statusCode: number;
|
|
1035
|
+
body: ListHotNewsWithTypeResponseBody;
|
|
1036
|
+
static names(): {
|
|
1037
|
+
[key: string]: string;
|
|
1038
|
+
};
|
|
1039
|
+
static types(): {
|
|
1040
|
+
[key: string]: any;
|
|
1041
|
+
};
|
|
1042
|
+
constructor(map?: {
|
|
1043
|
+
[key: string]: any;
|
|
1044
|
+
});
|
|
1045
|
+
}
|
|
1046
|
+
export declare class ListMaterialDocumentsRequest extends $tea.Model {
|
|
1047
|
+
agentKey?: string;
|
|
1048
|
+
content?: string;
|
|
1049
|
+
createTimeEnd?: string;
|
|
1050
|
+
createTimeStart?: string;
|
|
1051
|
+
current?: number;
|
|
1052
|
+
docType?: string;
|
|
1053
|
+
docTypeList?: string[];
|
|
1054
|
+
generatePublicUrl?: boolean;
|
|
1055
|
+
id?: number;
|
|
1056
|
+
keywords?: string[];
|
|
1057
|
+
query?: string;
|
|
1058
|
+
shareAttr?: number;
|
|
1059
|
+
size?: number;
|
|
1060
|
+
title?: string;
|
|
1061
|
+
updateTimeEnd?: string;
|
|
1062
|
+
updateTimeStart?: string;
|
|
1063
|
+
static names(): {
|
|
1064
|
+
[key: string]: string;
|
|
1065
|
+
};
|
|
1066
|
+
static types(): {
|
|
1067
|
+
[key: string]: any;
|
|
1068
|
+
};
|
|
1069
|
+
constructor(map?: {
|
|
1070
|
+
[key: string]: any;
|
|
1071
|
+
});
|
|
1072
|
+
}
|
|
1073
|
+
export declare class ListMaterialDocumentsShrinkRequest extends $tea.Model {
|
|
1074
|
+
agentKey?: string;
|
|
1075
|
+
content?: string;
|
|
1076
|
+
createTimeEnd?: string;
|
|
1077
|
+
createTimeStart?: string;
|
|
1078
|
+
current?: number;
|
|
1079
|
+
docType?: string;
|
|
1080
|
+
docTypeListShrink?: string;
|
|
1081
|
+
generatePublicUrl?: boolean;
|
|
1082
|
+
id?: number;
|
|
1083
|
+
keywordsShrink?: string;
|
|
1084
|
+
query?: string;
|
|
1085
|
+
shareAttr?: number;
|
|
1086
|
+
size?: number;
|
|
1087
|
+
title?: string;
|
|
1088
|
+
updateTimeEnd?: string;
|
|
1089
|
+
updateTimeStart?: string;
|
|
1090
|
+
static names(): {
|
|
1091
|
+
[key: string]: string;
|
|
1092
|
+
};
|
|
1093
|
+
static types(): {
|
|
1094
|
+
[key: string]: any;
|
|
1095
|
+
};
|
|
1096
|
+
constructor(map?: {
|
|
1097
|
+
[key: string]: any;
|
|
1098
|
+
});
|
|
1099
|
+
}
|
|
1100
|
+
export declare class ListMaterialDocumentsResponseBody extends $tea.Model {
|
|
1101
|
+
code?: string;
|
|
1102
|
+
current?: number;
|
|
1103
|
+
data?: ListMaterialDocumentsResponseBodyData[];
|
|
1104
|
+
httpStatusCode?: number;
|
|
1105
|
+
message?: string;
|
|
1106
|
+
requestId?: string;
|
|
1107
|
+
size?: number;
|
|
1108
|
+
success?: boolean;
|
|
1109
|
+
total?: number;
|
|
1110
|
+
static names(): {
|
|
1111
|
+
[key: string]: string;
|
|
1112
|
+
};
|
|
1113
|
+
static types(): {
|
|
1114
|
+
[key: string]: any;
|
|
1115
|
+
};
|
|
1116
|
+
constructor(map?: {
|
|
1117
|
+
[key: string]: any;
|
|
1118
|
+
});
|
|
1119
|
+
}
|
|
1120
|
+
export declare class ListMaterialDocumentsResponse extends $tea.Model {
|
|
1121
|
+
headers: {
|
|
1122
|
+
[key: string]: string;
|
|
1123
|
+
};
|
|
1124
|
+
statusCode: number;
|
|
1125
|
+
body: ListMaterialDocumentsResponseBody;
|
|
1126
|
+
static names(): {
|
|
1127
|
+
[key: string]: string;
|
|
1128
|
+
};
|
|
1129
|
+
static types(): {
|
|
1130
|
+
[key: string]: any;
|
|
1131
|
+
};
|
|
1132
|
+
constructor(map?: {
|
|
1133
|
+
[key: string]: any;
|
|
1134
|
+
});
|
|
1135
|
+
}
|
|
1136
|
+
export declare class ListVersionsRequest extends $tea.Model {
|
|
1137
|
+
agentKey?: string;
|
|
1138
|
+
static names(): {
|
|
1139
|
+
[key: string]: string;
|
|
1140
|
+
};
|
|
1141
|
+
static types(): {
|
|
1142
|
+
[key: string]: any;
|
|
1143
|
+
};
|
|
1144
|
+
constructor(map?: {
|
|
1145
|
+
[key: string]: any;
|
|
1146
|
+
});
|
|
1147
|
+
}
|
|
1148
|
+
export declare class ListVersionsResponseBody extends $tea.Model {
|
|
1149
|
+
code?: string;
|
|
1150
|
+
data?: ListVersionsResponseBodyData[];
|
|
1151
|
+
httpStatusCode?: number;
|
|
1152
|
+
message?: string;
|
|
1153
|
+
requestId?: string;
|
|
1154
|
+
success?: boolean;
|
|
1155
|
+
static names(): {
|
|
1156
|
+
[key: string]: string;
|
|
1157
|
+
};
|
|
1158
|
+
static types(): {
|
|
1159
|
+
[key: string]: any;
|
|
1160
|
+
};
|
|
1161
|
+
constructor(map?: {
|
|
1162
|
+
[key: string]: any;
|
|
1163
|
+
});
|
|
1164
|
+
}
|
|
1165
|
+
export declare class ListVersionsResponse extends $tea.Model {
|
|
1166
|
+
headers: {
|
|
1167
|
+
[key: string]: string;
|
|
1168
|
+
};
|
|
1169
|
+
statusCode: number;
|
|
1170
|
+
body: ListVersionsResponseBody;
|
|
1171
|
+
static names(): {
|
|
1172
|
+
[key: string]: string;
|
|
1173
|
+
};
|
|
1174
|
+
static types(): {
|
|
1175
|
+
[key: string]: any;
|
|
1176
|
+
};
|
|
1177
|
+
constructor(map?: {
|
|
1178
|
+
[key: string]: any;
|
|
1179
|
+
});
|
|
1180
|
+
}
|
|
1181
|
+
export declare class QueryAsyncTaskRequest extends $tea.Model {
|
|
1182
|
+
agentKey?: string;
|
|
1183
|
+
taskId?: string;
|
|
1184
|
+
static names(): {
|
|
1185
|
+
[key: string]: string;
|
|
1186
|
+
};
|
|
1187
|
+
static types(): {
|
|
1188
|
+
[key: string]: any;
|
|
1189
|
+
};
|
|
1190
|
+
constructor(map?: {
|
|
1191
|
+
[key: string]: any;
|
|
1192
|
+
});
|
|
1193
|
+
}
|
|
1194
|
+
export declare class QueryAsyncTaskResponseBody extends $tea.Model {
|
|
1195
|
+
code?: string;
|
|
1196
|
+
data?: QueryAsyncTaskResponseBodyData;
|
|
1197
|
+
httpStatusCode?: number;
|
|
1198
|
+
message?: string;
|
|
1199
|
+
requestId?: string;
|
|
1200
|
+
success?: boolean;
|
|
1201
|
+
static names(): {
|
|
1202
|
+
[key: string]: string;
|
|
1203
|
+
};
|
|
1204
|
+
static types(): {
|
|
1205
|
+
[key: string]: any;
|
|
1206
|
+
};
|
|
1207
|
+
constructor(map?: {
|
|
1208
|
+
[key: string]: any;
|
|
1209
|
+
});
|
|
1210
|
+
}
|
|
1211
|
+
export declare class QueryAsyncTaskResponse extends $tea.Model {
|
|
1212
|
+
headers: {
|
|
1213
|
+
[key: string]: string;
|
|
1214
|
+
};
|
|
1215
|
+
statusCode: number;
|
|
1216
|
+
body: QueryAsyncTaskResponseBody;
|
|
1217
|
+
static names(): {
|
|
1218
|
+
[key: string]: string;
|
|
1219
|
+
};
|
|
1220
|
+
static types(): {
|
|
1221
|
+
[key: string]: any;
|
|
1222
|
+
};
|
|
1223
|
+
constructor(map?: {
|
|
1224
|
+
[key: string]: any;
|
|
1225
|
+
});
|
|
1226
|
+
}
|
|
1227
|
+
export declare class SaveDataSourceOrderConfigRequest extends $tea.Model {
|
|
1228
|
+
agentKey?: string;
|
|
1229
|
+
productCode?: string;
|
|
1230
|
+
userConfigDataSourceList?: SaveDataSourceOrderConfigRequestUserConfigDataSourceList[];
|
|
1231
|
+
static names(): {
|
|
1232
|
+
[key: string]: string;
|
|
1233
|
+
};
|
|
1234
|
+
static types(): {
|
|
1235
|
+
[key: string]: any;
|
|
1236
|
+
};
|
|
1237
|
+
constructor(map?: {
|
|
1238
|
+
[key: string]: any;
|
|
1239
|
+
});
|
|
1240
|
+
}
|
|
1241
|
+
export declare class SaveDataSourceOrderConfigShrinkRequest extends $tea.Model {
|
|
1242
|
+
agentKey?: string;
|
|
1243
|
+
productCode?: string;
|
|
1244
|
+
userConfigDataSourceListShrink?: string;
|
|
1245
|
+
static names(): {
|
|
1246
|
+
[key: string]: string;
|
|
1247
|
+
};
|
|
1248
|
+
static types(): {
|
|
1249
|
+
[key: string]: any;
|
|
1250
|
+
};
|
|
1251
|
+
constructor(map?: {
|
|
1252
|
+
[key: string]: any;
|
|
1253
|
+
});
|
|
1254
|
+
}
|
|
1255
|
+
export declare class SaveDataSourceOrderConfigResponseBody extends $tea.Model {
|
|
1256
|
+
code?: string;
|
|
1257
|
+
data?: boolean;
|
|
1258
|
+
httpStatusCode?: number;
|
|
1259
|
+
message?: string;
|
|
1260
|
+
requestId?: string;
|
|
1261
|
+
success?: boolean;
|
|
1262
|
+
static names(): {
|
|
1263
|
+
[key: string]: string;
|
|
1264
|
+
};
|
|
1265
|
+
static types(): {
|
|
1266
|
+
[key: string]: any;
|
|
1267
|
+
};
|
|
1268
|
+
constructor(map?: {
|
|
1269
|
+
[key: string]: any;
|
|
1270
|
+
});
|
|
1271
|
+
}
|
|
1272
|
+
export declare class SaveDataSourceOrderConfigResponse extends $tea.Model {
|
|
1273
|
+
headers: {
|
|
1274
|
+
[key: string]: string;
|
|
1275
|
+
};
|
|
1276
|
+
statusCode: number;
|
|
1277
|
+
body: SaveDataSourceOrderConfigResponseBody;
|
|
1278
|
+
static names(): {
|
|
1279
|
+
[key: string]: string;
|
|
1280
|
+
};
|
|
1281
|
+
static types(): {
|
|
1282
|
+
[key: string]: any;
|
|
1283
|
+
};
|
|
1284
|
+
constructor(map?: {
|
|
1285
|
+
[key: string]: any;
|
|
1286
|
+
});
|
|
1287
|
+
}
|
|
1288
|
+
export declare class SaveMaterialDocumentRequest extends $tea.Model {
|
|
1289
|
+
agentKey?: string;
|
|
1290
|
+
author?: string;
|
|
1291
|
+
bothSavePrivateAndShare?: boolean;
|
|
1292
|
+
docKeywords?: string[];
|
|
1293
|
+
docType?: string;
|
|
1294
|
+
externalUrl?: string;
|
|
1295
|
+
htmlContent?: string;
|
|
1296
|
+
pubTime?: string;
|
|
1297
|
+
shareAttr?: number;
|
|
1298
|
+
srcFrom?: string;
|
|
1299
|
+
summary?: string;
|
|
1300
|
+
textContent?: string;
|
|
1301
|
+
title?: string;
|
|
1302
|
+
url?: string;
|
|
1303
|
+
static names(): {
|
|
1304
|
+
[key: string]: string;
|
|
1305
|
+
};
|
|
1306
|
+
static types(): {
|
|
1307
|
+
[key: string]: any;
|
|
1308
|
+
};
|
|
1309
|
+
constructor(map?: {
|
|
1310
|
+
[key: string]: any;
|
|
1311
|
+
});
|
|
1312
|
+
}
|
|
1313
|
+
export declare class SaveMaterialDocumentShrinkRequest extends $tea.Model {
|
|
1314
|
+
agentKey?: string;
|
|
1315
|
+
author?: string;
|
|
1316
|
+
bothSavePrivateAndShare?: boolean;
|
|
1317
|
+
docKeywordsShrink?: string;
|
|
1318
|
+
docType?: string;
|
|
1319
|
+
externalUrl?: string;
|
|
1320
|
+
htmlContent?: string;
|
|
1321
|
+
pubTime?: string;
|
|
1322
|
+
shareAttr?: number;
|
|
1323
|
+
srcFrom?: string;
|
|
1324
|
+
summary?: string;
|
|
1325
|
+
textContent?: string;
|
|
1326
|
+
title?: string;
|
|
1327
|
+
url?: string;
|
|
1328
|
+
static names(): {
|
|
1329
|
+
[key: string]: string;
|
|
1330
|
+
};
|
|
1331
|
+
static types(): {
|
|
1332
|
+
[key: string]: any;
|
|
1333
|
+
};
|
|
1334
|
+
constructor(map?: {
|
|
1335
|
+
[key: string]: any;
|
|
1336
|
+
});
|
|
1337
|
+
}
|
|
1338
|
+
export declare class SaveMaterialDocumentResponseBody extends $tea.Model {
|
|
1339
|
+
code?: string;
|
|
1340
|
+
data?: number;
|
|
1341
|
+
httpStatusCode?: number;
|
|
1342
|
+
message?: string;
|
|
1343
|
+
requestId?: string;
|
|
1344
|
+
success?: boolean;
|
|
1345
|
+
static names(): {
|
|
1346
|
+
[key: string]: string;
|
|
1347
|
+
};
|
|
1348
|
+
static types(): {
|
|
1349
|
+
[key: string]: any;
|
|
1350
|
+
};
|
|
1351
|
+
constructor(map?: {
|
|
1352
|
+
[key: string]: any;
|
|
1353
|
+
});
|
|
1354
|
+
}
|
|
1355
|
+
export declare class SaveMaterialDocumentResponse extends $tea.Model {
|
|
1356
|
+
headers: {
|
|
1357
|
+
[key: string]: string;
|
|
1358
|
+
};
|
|
1359
|
+
statusCode: number;
|
|
1360
|
+
body: SaveMaterialDocumentResponseBody;
|
|
1361
|
+
static names(): {
|
|
1362
|
+
[key: string]: string;
|
|
1363
|
+
};
|
|
1364
|
+
static types(): {
|
|
1365
|
+
[key: string]: any;
|
|
1366
|
+
};
|
|
1367
|
+
constructor(map?: {
|
|
1368
|
+
[key: string]: any;
|
|
1369
|
+
});
|
|
1370
|
+
}
|
|
1371
|
+
export declare class SubmitAsyncTaskRequest extends $tea.Model {
|
|
1372
|
+
agentKey?: string;
|
|
1373
|
+
taskCode?: string;
|
|
1374
|
+
taskExecuteTime?: string;
|
|
1375
|
+
taskName?: string;
|
|
1376
|
+
taskParam?: string;
|
|
1377
|
+
static names(): {
|
|
1378
|
+
[key: string]: string;
|
|
1379
|
+
};
|
|
1380
|
+
static types(): {
|
|
1381
|
+
[key: string]: any;
|
|
1382
|
+
};
|
|
1383
|
+
constructor(map?: {
|
|
1384
|
+
[key: string]: any;
|
|
1385
|
+
});
|
|
1386
|
+
}
|
|
1387
|
+
export declare class SubmitAsyncTaskResponseBody extends $tea.Model {
|
|
1388
|
+
code?: string;
|
|
1389
|
+
data?: SubmitAsyncTaskResponseBodyData;
|
|
1390
|
+
httpStatusCode?: number;
|
|
1391
|
+
message?: string;
|
|
1392
|
+
requestId?: string;
|
|
1393
|
+
success?: boolean;
|
|
1394
|
+
static names(): {
|
|
1395
|
+
[key: string]: string;
|
|
1396
|
+
};
|
|
1397
|
+
static types(): {
|
|
1398
|
+
[key: string]: any;
|
|
1399
|
+
};
|
|
1400
|
+
constructor(map?: {
|
|
1401
|
+
[key: string]: any;
|
|
1402
|
+
});
|
|
1403
|
+
}
|
|
1404
|
+
export declare class SubmitAsyncTaskResponse extends $tea.Model {
|
|
1405
|
+
headers: {
|
|
1406
|
+
[key: string]: string;
|
|
1407
|
+
};
|
|
1408
|
+
statusCode: number;
|
|
1409
|
+
body: SubmitAsyncTaskResponseBody;
|
|
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 UpdateMaterialDocumentRequest extends $tea.Model {
|
|
1421
|
+
agentKey?: string;
|
|
1422
|
+
author?: string;
|
|
1423
|
+
docKeywords?: string[];
|
|
1424
|
+
docType?: string;
|
|
1425
|
+
externalUrl?: string;
|
|
1426
|
+
htmlContent?: string;
|
|
1427
|
+
id?: number;
|
|
1428
|
+
pubTime?: string;
|
|
1429
|
+
shareAttr?: number;
|
|
1430
|
+
srcFrom?: string;
|
|
1431
|
+
summary?: string;
|
|
1432
|
+
textContent?: string;
|
|
1433
|
+
title?: string;
|
|
1434
|
+
url?: string;
|
|
1435
|
+
static names(): {
|
|
1436
|
+
[key: string]: string;
|
|
1437
|
+
};
|
|
1438
|
+
static types(): {
|
|
1439
|
+
[key: string]: any;
|
|
1440
|
+
};
|
|
1441
|
+
constructor(map?: {
|
|
1442
|
+
[key: string]: any;
|
|
1443
|
+
});
|
|
1444
|
+
}
|
|
1445
|
+
export declare class UpdateMaterialDocumentShrinkRequest extends $tea.Model {
|
|
1446
|
+
agentKey?: string;
|
|
1447
|
+
author?: string;
|
|
1448
|
+
docKeywordsShrink?: string;
|
|
1449
|
+
docType?: string;
|
|
1450
|
+
externalUrl?: string;
|
|
1451
|
+
htmlContent?: string;
|
|
1452
|
+
id?: number;
|
|
1453
|
+
pubTime?: string;
|
|
1454
|
+
shareAttr?: number;
|
|
1455
|
+
srcFrom?: string;
|
|
1456
|
+
summary?: string;
|
|
1457
|
+
textContent?: string;
|
|
1458
|
+
title?: string;
|
|
1459
|
+
url?: 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 UpdateMaterialDocumentResponseBody extends $tea.Model {
|
|
1471
|
+
code?: string;
|
|
1472
|
+
data?: number;
|
|
1473
|
+
httpStatusCode?: number;
|
|
1474
|
+
message?: string;
|
|
1475
|
+
requestId?: string;
|
|
1476
|
+
success?: boolean;
|
|
1477
|
+
static names(): {
|
|
1478
|
+
[key: string]: string;
|
|
1479
|
+
};
|
|
1480
|
+
static types(): {
|
|
1481
|
+
[key: string]: any;
|
|
1482
|
+
};
|
|
1483
|
+
constructor(map?: {
|
|
1484
|
+
[key: string]: any;
|
|
1485
|
+
});
|
|
1486
|
+
}
|
|
1487
|
+
export declare class UpdateMaterialDocumentResponse extends $tea.Model {
|
|
1488
|
+
headers: {
|
|
1489
|
+
[key: string]: string;
|
|
1490
|
+
};
|
|
1491
|
+
statusCode: number;
|
|
1492
|
+
body: UpdateMaterialDocumentResponseBody;
|
|
1493
|
+
static names(): {
|
|
1494
|
+
[key: string]: string;
|
|
1495
|
+
};
|
|
1496
|
+
static types(): {
|
|
1497
|
+
[key: string]: any;
|
|
1498
|
+
};
|
|
1499
|
+
constructor(map?: {
|
|
1500
|
+
[key: string]: any;
|
|
1501
|
+
});
|
|
1502
|
+
}
|
|
1503
|
+
export declare class CreateTokenResponseBodyData extends $tea.Model {
|
|
1504
|
+
expiredTime?: number;
|
|
1505
|
+
token?: 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 FetchImageTaskResponseBodyDataTaskInfoListImageList extends $tea.Model {
|
|
1517
|
+
code?: string;
|
|
1518
|
+
message?: string;
|
|
1519
|
+
url?: string;
|
|
1520
|
+
static names(): {
|
|
1521
|
+
[key: string]: string;
|
|
1522
|
+
};
|
|
1523
|
+
static types(): {
|
|
1524
|
+
[key: string]: any;
|
|
1525
|
+
};
|
|
1526
|
+
constructor(map?: {
|
|
1527
|
+
[key: string]: any;
|
|
1528
|
+
});
|
|
1529
|
+
}
|
|
1530
|
+
export declare class FetchImageTaskResponseBodyDataTaskInfoList extends $tea.Model {
|
|
1531
|
+
id?: number;
|
|
1532
|
+
imageList?: FetchImageTaskResponseBodyDataTaskInfoListImageList[];
|
|
1533
|
+
taskId?: string;
|
|
1534
|
+
taskStatus?: string;
|
|
1535
|
+
static names(): {
|
|
1536
|
+
[key: string]: string;
|
|
1537
|
+
};
|
|
1538
|
+
static types(): {
|
|
1539
|
+
[key: string]: any;
|
|
1540
|
+
};
|
|
1541
|
+
constructor(map?: {
|
|
1542
|
+
[key: string]: any;
|
|
1543
|
+
});
|
|
1544
|
+
}
|
|
1545
|
+
export declare class FetchImageTaskResponseBodyData extends $tea.Model {
|
|
1546
|
+
taskInfoList?: FetchImageTaskResponseBodyDataTaskInfoList[];
|
|
1547
|
+
static names(): {
|
|
1548
|
+
[key: string]: string;
|
|
1549
|
+
};
|
|
1550
|
+
static types(): {
|
|
1551
|
+
[key: string]: any;
|
|
1552
|
+
};
|
|
1553
|
+
constructor(map?: {
|
|
1554
|
+
[key: string]: any;
|
|
1555
|
+
});
|
|
1556
|
+
}
|
|
1557
|
+
export declare class GenerateImageTaskRequestParagraphList extends $tea.Model {
|
|
1558
|
+
content?: string;
|
|
1559
|
+
id?: number;
|
|
1560
|
+
taskId?: string;
|
|
1561
|
+
taskStatus?: string;
|
|
1562
|
+
static names(): {
|
|
1563
|
+
[key: string]: string;
|
|
1564
|
+
};
|
|
1565
|
+
static types(): {
|
|
1566
|
+
[key: string]: any;
|
|
1567
|
+
};
|
|
1568
|
+
constructor(map?: {
|
|
1569
|
+
[key: string]: any;
|
|
1570
|
+
});
|
|
1571
|
+
}
|
|
1572
|
+
export declare class GenerateImageTaskResponseBodyDataTaskList extends $tea.Model {
|
|
1573
|
+
content?: string;
|
|
1574
|
+
id?: number;
|
|
1575
|
+
taskId?: string;
|
|
1576
|
+
taskStatus?: string;
|
|
1577
|
+
static names(): {
|
|
1578
|
+
[key: string]: string;
|
|
1579
|
+
};
|
|
1580
|
+
static types(): {
|
|
1581
|
+
[key: string]: any;
|
|
1582
|
+
};
|
|
1583
|
+
constructor(map?: {
|
|
1584
|
+
[key: string]: any;
|
|
1585
|
+
});
|
|
1586
|
+
}
|
|
1587
|
+
export declare class GenerateImageTaskResponseBodyData extends $tea.Model {
|
|
1588
|
+
taskList?: GenerateImageTaskResponseBodyDataTaskList[];
|
|
1589
|
+
static names(): {
|
|
1590
|
+
[key: string]: string;
|
|
1591
|
+
};
|
|
1592
|
+
static types(): {
|
|
1593
|
+
[key: string]: any;
|
|
1594
|
+
};
|
|
1595
|
+
constructor(map?: {
|
|
1596
|
+
[key: string]: any;
|
|
1597
|
+
});
|
|
1598
|
+
}
|
|
1599
|
+
export declare class GenerateViewPointRequestReferenceData extends $tea.Model {
|
|
1600
|
+
miniDoc?: string[];
|
|
1601
|
+
static names(): {
|
|
1602
|
+
[key: string]: string;
|
|
1603
|
+
};
|
|
1604
|
+
static types(): {
|
|
1605
|
+
[key: string]: any;
|
|
1606
|
+
};
|
|
1607
|
+
constructor(map?: {
|
|
1608
|
+
[key: string]: any;
|
|
1609
|
+
});
|
|
1610
|
+
}
|
|
1611
|
+
export declare class GenerateViewPointResponseBodyData extends $tea.Model {
|
|
1612
|
+
point?: string;
|
|
1613
|
+
static names(): {
|
|
1614
|
+
[key: string]: string;
|
|
1615
|
+
};
|
|
1616
|
+
static types(): {
|
|
1617
|
+
[key: string]: any;
|
|
1618
|
+
};
|
|
1619
|
+
constructor(map?: {
|
|
1620
|
+
[key: string]: any;
|
|
1621
|
+
});
|
|
1622
|
+
}
|
|
1623
|
+
export declare class GetDataSourceOrderConfigResponseBodyDataUserConfigDataSourceList extends $tea.Model {
|
|
1624
|
+
code?: string;
|
|
1625
|
+
name?: string;
|
|
1626
|
+
number?: number;
|
|
1627
|
+
type?: string;
|
|
1628
|
+
static names(): {
|
|
1629
|
+
[key: string]: string;
|
|
1630
|
+
};
|
|
1631
|
+
static types(): {
|
|
1632
|
+
[key: string]: any;
|
|
1633
|
+
};
|
|
1634
|
+
constructor(map?: {
|
|
1635
|
+
[key: string]: any;
|
|
1636
|
+
});
|
|
1637
|
+
}
|
|
1638
|
+
export declare class GetDataSourceOrderConfigResponseBodyData extends $tea.Model {
|
|
1639
|
+
userConfigDataSourceList?: GetDataSourceOrderConfigResponseBodyDataUserConfigDataSourceList[];
|
|
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 GetGeneratedContentResponseBodyData extends $tea.Model {
|
|
1651
|
+
content?: string;
|
|
1652
|
+
contentDomain?: string;
|
|
1653
|
+
contentText?: string;
|
|
1654
|
+
createTime?: string;
|
|
1655
|
+
createUser?: string;
|
|
1656
|
+
deviceId?: string;
|
|
1657
|
+
id?: number;
|
|
1658
|
+
keywordList?: string[];
|
|
1659
|
+
keywords?: string;
|
|
1660
|
+
prompt?: string;
|
|
1661
|
+
taskId?: string;
|
|
1662
|
+
title?: string;
|
|
1663
|
+
updateTime?: string;
|
|
1664
|
+
updateUser?: string;
|
|
1665
|
+
uuid?: string;
|
|
1666
|
+
static names(): {
|
|
1667
|
+
[key: string]: string;
|
|
1668
|
+
};
|
|
1669
|
+
static types(): {
|
|
1670
|
+
[key: string]: any;
|
|
1671
|
+
};
|
|
1672
|
+
constructor(map?: {
|
|
1673
|
+
[key: string]: any;
|
|
1674
|
+
});
|
|
1675
|
+
}
|
|
1676
|
+
export declare class GetMaterialByIdResponseBodyData extends $tea.Model {
|
|
1677
|
+
author?: string;
|
|
1678
|
+
createTime?: string;
|
|
1679
|
+
createUser?: string;
|
|
1680
|
+
docKeywords?: string[];
|
|
1681
|
+
docType?: string;
|
|
1682
|
+
externalUrl?: string;
|
|
1683
|
+
htmlContent?: string;
|
|
1684
|
+
id?: number;
|
|
1685
|
+
pubTime?: string;
|
|
1686
|
+
publicUrl?: string;
|
|
1687
|
+
shareAttr?: number;
|
|
1688
|
+
srcFrom?: string;
|
|
1689
|
+
summary?: string;
|
|
1690
|
+
textContent?: string;
|
|
1691
|
+
thumbnailInBase64?: string;
|
|
1692
|
+
title?: string;
|
|
1693
|
+
updateTime?: string;
|
|
1694
|
+
updateUser?: string;
|
|
1695
|
+
url?: string;
|
|
1696
|
+
static names(): {
|
|
1697
|
+
[key: string]: string;
|
|
1698
|
+
};
|
|
1699
|
+
static types(): {
|
|
1700
|
+
[key: string]: any;
|
|
1701
|
+
};
|
|
1702
|
+
constructor(map?: {
|
|
1703
|
+
[key: string]: any;
|
|
1704
|
+
});
|
|
1705
|
+
}
|
|
1706
|
+
export declare class GetPropertiesResponseBodyDataConsoleConfig extends $tea.Model {
|
|
1707
|
+
tipContent?: string;
|
|
1708
|
+
title?: string;
|
|
1709
|
+
static names(): {
|
|
1710
|
+
[key: string]: string;
|
|
1711
|
+
};
|
|
1712
|
+
static types(): {
|
|
1713
|
+
[key: string]: any;
|
|
1714
|
+
};
|
|
1715
|
+
constructor(map?: {
|
|
1716
|
+
[key: string]: any;
|
|
1717
|
+
});
|
|
1718
|
+
}
|
|
1719
|
+
export declare class GetPropertiesResponseBodyDataIntelligentSearchConfigSearchSamplesArticles extends $tea.Model {
|
|
1720
|
+
select?: boolean;
|
|
1721
|
+
stared?: boolean;
|
|
1722
|
+
title?: string;
|
|
1723
|
+
url?: string;
|
|
1724
|
+
static names(): {
|
|
1725
|
+
[key: string]: string;
|
|
1726
|
+
};
|
|
1727
|
+
static types(): {
|
|
1728
|
+
[key: string]: any;
|
|
1729
|
+
};
|
|
1730
|
+
constructor(map?: {
|
|
1731
|
+
[key: string]: any;
|
|
1732
|
+
});
|
|
1733
|
+
}
|
|
1734
|
+
export declare class GetPropertiesResponseBodyDataIntelligentSearchConfigSearchSamples extends $tea.Model {
|
|
1735
|
+
articles?: GetPropertiesResponseBodyDataIntelligentSearchConfigSearchSamplesArticles[];
|
|
1736
|
+
prompt?: string;
|
|
1737
|
+
text?: string;
|
|
1738
|
+
static names(): {
|
|
1739
|
+
[key: string]: string;
|
|
1740
|
+
};
|
|
1741
|
+
static types(): {
|
|
1742
|
+
[key: string]: any;
|
|
1743
|
+
};
|
|
1744
|
+
constructor(map?: {
|
|
1745
|
+
[key: string]: any;
|
|
1746
|
+
});
|
|
1747
|
+
}
|
|
1748
|
+
export declare class GetPropertiesResponseBodyDataIntelligentSearchConfigSearchSources extends $tea.Model {
|
|
1749
|
+
code?: string;
|
|
1750
|
+
datasetName?: string;
|
|
1751
|
+
name?: string;
|
|
1752
|
+
static names(): {
|
|
1753
|
+
[key: string]: string;
|
|
1754
|
+
};
|
|
1755
|
+
static types(): {
|
|
1756
|
+
[key: string]: any;
|
|
1757
|
+
};
|
|
1758
|
+
constructor(map?: {
|
|
1759
|
+
[key: string]: any;
|
|
1760
|
+
});
|
|
1761
|
+
}
|
|
1762
|
+
export declare class GetPropertiesResponseBodyDataIntelligentSearchConfig extends $tea.Model {
|
|
1763
|
+
productDescription?: string;
|
|
1764
|
+
searchSamples?: GetPropertiesResponseBodyDataIntelligentSearchConfigSearchSamples[];
|
|
1765
|
+
searchSources?: GetPropertiesResponseBodyDataIntelligentSearchConfigSearchSources[];
|
|
1766
|
+
static names(): {
|
|
1767
|
+
[key: string]: string;
|
|
1768
|
+
};
|
|
1769
|
+
static types(): {
|
|
1770
|
+
[key: string]: any;
|
|
1771
|
+
};
|
|
1772
|
+
constructor(map?: {
|
|
1773
|
+
[key: string]: any;
|
|
1774
|
+
});
|
|
1775
|
+
}
|
|
1776
|
+
export declare class GetPropertiesResponseBodyDataSearchSources extends $tea.Model {
|
|
1777
|
+
label?: string;
|
|
1778
|
+
value?: string;
|
|
1779
|
+
static names(): {
|
|
1780
|
+
[key: string]: string;
|
|
1781
|
+
};
|
|
1782
|
+
static types(): {
|
|
1783
|
+
[key: string]: any;
|
|
1784
|
+
};
|
|
1785
|
+
constructor(map?: {
|
|
1786
|
+
[key: string]: any;
|
|
1787
|
+
});
|
|
1788
|
+
}
|
|
1789
|
+
export declare class GetPropertiesResponseBodyDataUserInfo extends $tea.Model {
|
|
1790
|
+
agentId?: string;
|
|
1791
|
+
tenantId?: string;
|
|
1792
|
+
userId?: string;
|
|
1793
|
+
username?: string;
|
|
1794
|
+
static names(): {
|
|
1795
|
+
[key: string]: string;
|
|
1796
|
+
};
|
|
1797
|
+
static types(): {
|
|
1798
|
+
[key: string]: any;
|
|
1799
|
+
};
|
|
1800
|
+
constructor(map?: {
|
|
1801
|
+
[key: string]: any;
|
|
1802
|
+
});
|
|
1803
|
+
}
|
|
1804
|
+
export declare class GetPropertiesResponseBodyDataWanxiangImageSizeConfig extends $tea.Model {
|
|
1805
|
+
name?: string;
|
|
1806
|
+
value?: string;
|
|
1807
|
+
static names(): {
|
|
1808
|
+
[key: string]: string;
|
|
1809
|
+
};
|
|
1810
|
+
static types(): {
|
|
1811
|
+
[key: string]: any;
|
|
1812
|
+
};
|
|
1813
|
+
constructor(map?: {
|
|
1814
|
+
[key: string]: any;
|
|
1815
|
+
});
|
|
1816
|
+
}
|
|
1817
|
+
export declare class GetPropertiesResponseBodyDataWanxiangImageStyleConfig extends $tea.Model {
|
|
1818
|
+
name?: string;
|
|
1819
|
+
pic?: string;
|
|
1820
|
+
value?: string;
|
|
1821
|
+
static names(): {
|
|
1822
|
+
[key: string]: string;
|
|
1823
|
+
};
|
|
1824
|
+
static types(): {
|
|
1825
|
+
[key: string]: any;
|
|
1826
|
+
};
|
|
1827
|
+
constructor(map?: {
|
|
1828
|
+
[key: string]: any;
|
|
1829
|
+
});
|
|
1830
|
+
}
|
|
1831
|
+
export declare class GetPropertiesResponseBodyData extends $tea.Model {
|
|
1832
|
+
chatConfig?: {
|
|
1833
|
+
[key: string]: any;
|
|
1834
|
+
};
|
|
1835
|
+
consoleConfig?: GetPropertiesResponseBodyDataConsoleConfig;
|
|
1836
|
+
generalConfigMap?: {
|
|
1837
|
+
[key: string]: any;
|
|
1838
|
+
};
|
|
1839
|
+
intelligentSearchConfig?: GetPropertiesResponseBodyDataIntelligentSearchConfig;
|
|
1840
|
+
searchSources?: GetPropertiesResponseBodyDataSearchSources[];
|
|
1841
|
+
slrAuthorized?: boolean;
|
|
1842
|
+
userInfo?: GetPropertiesResponseBodyDataUserInfo;
|
|
1843
|
+
wanxiangImageSizeConfig?: GetPropertiesResponseBodyDataWanxiangImageSizeConfig[];
|
|
1844
|
+
wanxiangImageStyleConfig?: GetPropertiesResponseBodyDataWanxiangImageStyleConfig[];
|
|
1845
|
+
static names(): {
|
|
1846
|
+
[key: string]: string;
|
|
1847
|
+
};
|
|
1848
|
+
static types(): {
|
|
1849
|
+
[key: string]: any;
|
|
1850
|
+
};
|
|
1851
|
+
constructor(map?: {
|
|
1852
|
+
[key: string]: any;
|
|
1853
|
+
});
|
|
1854
|
+
}
|
|
1855
|
+
export declare class ListAsyncTasksResponseBodyData extends $tea.Model {
|
|
1856
|
+
createTime?: string;
|
|
1857
|
+
createUser?: string;
|
|
1858
|
+
id?: number;
|
|
1859
|
+
taskCode?: string;
|
|
1860
|
+
taskDefinition?: string;
|
|
1861
|
+
taskEndTime?: string;
|
|
1862
|
+
taskErrorMessage?: string;
|
|
1863
|
+
taskExecuteTime?: string;
|
|
1864
|
+
taskId?: string;
|
|
1865
|
+
taskInnerErrorMessage?: string;
|
|
1866
|
+
taskIntermediateResult?: string;
|
|
1867
|
+
taskName?: string;
|
|
1868
|
+
taskParam?: string;
|
|
1869
|
+
taskProgressMessage?: string;
|
|
1870
|
+
taskResult?: string;
|
|
1871
|
+
taskRetryCount?: string;
|
|
1872
|
+
taskStartTime?: string;
|
|
1873
|
+
taskStatus?: number;
|
|
1874
|
+
taskType?: string;
|
|
1875
|
+
updateTime?: string;
|
|
1876
|
+
updateUser?: string;
|
|
1877
|
+
static names(): {
|
|
1878
|
+
[key: string]: string;
|
|
1879
|
+
};
|
|
1880
|
+
static types(): {
|
|
1881
|
+
[key: string]: any;
|
|
1882
|
+
};
|
|
1883
|
+
constructor(map?: {
|
|
1884
|
+
[key: string]: any;
|
|
1885
|
+
});
|
|
1886
|
+
}
|
|
1887
|
+
export declare class ListBuildConfigsResponseBodyDataKeywords extends $tea.Model {
|
|
1888
|
+
description?: string;
|
|
1889
|
+
key?: string;
|
|
1890
|
+
static names(): {
|
|
1891
|
+
[key: string]: string;
|
|
1892
|
+
};
|
|
1893
|
+
static types(): {
|
|
1894
|
+
[key: string]: any;
|
|
1895
|
+
};
|
|
1896
|
+
constructor(map?: {
|
|
1897
|
+
[key: string]: any;
|
|
1898
|
+
});
|
|
1899
|
+
}
|
|
1900
|
+
export declare class ListBuildConfigsResponseBodyData extends $tea.Model {
|
|
1901
|
+
buildIn?: boolean;
|
|
1902
|
+
createTime?: string;
|
|
1903
|
+
createUser?: string;
|
|
1904
|
+
id?: number;
|
|
1905
|
+
keywords?: ListBuildConfigsResponseBodyDataKeywords[];
|
|
1906
|
+
tag?: string;
|
|
1907
|
+
tagDescription?: string;
|
|
1908
|
+
type?: string;
|
|
1909
|
+
updateTime?: string;
|
|
1910
|
+
updateUser?: string;
|
|
1911
|
+
static names(): {
|
|
1912
|
+
[key: string]: string;
|
|
1913
|
+
};
|
|
1914
|
+
static types(): {
|
|
1915
|
+
[key: string]: any;
|
|
1916
|
+
};
|
|
1917
|
+
constructor(map?: {
|
|
1918
|
+
[key: string]: any;
|
|
1919
|
+
});
|
|
1920
|
+
}
|
|
1921
|
+
export declare class ListDialoguesResponseBodyData extends $tea.Model {
|
|
1922
|
+
bot?: string;
|
|
1923
|
+
createTime?: string;
|
|
1924
|
+
createUser?: string;
|
|
1925
|
+
dialogueType?: number;
|
|
1926
|
+
taskId?: string;
|
|
1927
|
+
user?: string;
|
|
1928
|
+
static names(): {
|
|
1929
|
+
[key: string]: string;
|
|
1930
|
+
};
|
|
1931
|
+
static types(): {
|
|
1932
|
+
[key: string]: any;
|
|
1933
|
+
};
|
|
1934
|
+
constructor(map?: {
|
|
1935
|
+
[key: string]: any;
|
|
1936
|
+
});
|
|
1937
|
+
}
|
|
1938
|
+
export declare class ListGeneratedContentsResponseBodyData extends $tea.Model {
|
|
1939
|
+
content?: string;
|
|
1940
|
+
contentDomain?: string;
|
|
1941
|
+
contentText?: string;
|
|
1942
|
+
createTime?: string;
|
|
1943
|
+
createUser?: string;
|
|
1944
|
+
deviceId?: string;
|
|
1945
|
+
id?: number;
|
|
1946
|
+
keywordList?: string[];
|
|
1947
|
+
keywords?: string;
|
|
1948
|
+
prompt?: string;
|
|
1949
|
+
taskId?: string;
|
|
1950
|
+
title?: string;
|
|
1951
|
+
updateTime?: string;
|
|
1952
|
+
updateUser?: string;
|
|
1953
|
+
uuid?: string;
|
|
1954
|
+
static names(): {
|
|
1955
|
+
[key: string]: string;
|
|
1956
|
+
};
|
|
1957
|
+
static types(): {
|
|
1958
|
+
[key: string]: any;
|
|
1959
|
+
};
|
|
1960
|
+
constructor(map?: {
|
|
1961
|
+
[key: string]: any;
|
|
1962
|
+
});
|
|
1963
|
+
}
|
|
1964
|
+
export declare class ListHotNewsWithTypeResponseBodyDataNews extends $tea.Model {
|
|
1965
|
+
author?: string;
|
|
1966
|
+
content?: string;
|
|
1967
|
+
docUuid?: string;
|
|
1968
|
+
imageUrls?: string[];
|
|
1969
|
+
pubTime?: string;
|
|
1970
|
+
searchSource?: string;
|
|
1971
|
+
searchSourceName?: string;
|
|
1972
|
+
source?: string;
|
|
1973
|
+
summary?: string;
|
|
1974
|
+
tag?: string;
|
|
1975
|
+
title?: string;
|
|
1976
|
+
updateTime?: string;
|
|
1977
|
+
url?: string;
|
|
1978
|
+
static names(): {
|
|
1979
|
+
[key: string]: string;
|
|
1980
|
+
};
|
|
1981
|
+
static types(): {
|
|
1982
|
+
[key: string]: any;
|
|
1983
|
+
};
|
|
1984
|
+
constructor(map?: {
|
|
1985
|
+
[key: string]: any;
|
|
1986
|
+
});
|
|
1987
|
+
}
|
|
1988
|
+
export declare class ListHotNewsWithTypeResponseBodyData extends $tea.Model {
|
|
1989
|
+
news?: ListHotNewsWithTypeResponseBodyDataNews[];
|
|
1990
|
+
newsType?: string;
|
|
1991
|
+
newsTypeName?: string;
|
|
1992
|
+
totalPages?: number;
|
|
1993
|
+
static names(): {
|
|
1994
|
+
[key: string]: string;
|
|
1995
|
+
};
|
|
1996
|
+
static types(): {
|
|
1997
|
+
[key: string]: any;
|
|
1998
|
+
};
|
|
1999
|
+
constructor(map?: {
|
|
2000
|
+
[key: string]: any;
|
|
2001
|
+
});
|
|
2002
|
+
}
|
|
2003
|
+
export declare class ListMaterialDocumentsResponseBodyData extends $tea.Model {
|
|
2004
|
+
author?: string;
|
|
2005
|
+
createTime?: string;
|
|
2006
|
+
createUser?: string;
|
|
2007
|
+
createUserName?: string;
|
|
2008
|
+
docKeywords?: string[];
|
|
2009
|
+
docType?: string;
|
|
2010
|
+
externalUrl?: string;
|
|
2011
|
+
htmlContent?: string;
|
|
2012
|
+
id?: number;
|
|
2013
|
+
pubTime?: string;
|
|
2014
|
+
publicUrl?: string;
|
|
2015
|
+
shareAttr?: number;
|
|
2016
|
+
srcFrom?: string;
|
|
2017
|
+
summary?: string;
|
|
2018
|
+
textContent?: string;
|
|
2019
|
+
thumbnailInBase64?: string;
|
|
2020
|
+
title?: string;
|
|
2021
|
+
updateTime?: string;
|
|
2022
|
+
updateUser?: string;
|
|
2023
|
+
updateUserName?: string;
|
|
2024
|
+
url?: string;
|
|
2025
|
+
static names(): {
|
|
2026
|
+
[key: string]: string;
|
|
2027
|
+
};
|
|
2028
|
+
static types(): {
|
|
2029
|
+
[key: string]: any;
|
|
2030
|
+
};
|
|
2031
|
+
constructor(map?: {
|
|
2032
|
+
[key: string]: any;
|
|
2033
|
+
});
|
|
2034
|
+
}
|
|
2035
|
+
export declare class ListVersionsResponseBodyData extends $tea.Model {
|
|
2036
|
+
concurrentCount?: number;
|
|
2037
|
+
endTime?: string;
|
|
2038
|
+
instanceCount?: number;
|
|
2039
|
+
instanceId?: string;
|
|
2040
|
+
orderId?: number;
|
|
2041
|
+
productType?: string;
|
|
2042
|
+
quota?: number;
|
|
2043
|
+
startTime?: string;
|
|
2044
|
+
useQuota?: number;
|
|
2045
|
+
versionDetail?: string;
|
|
2046
|
+
versionName?: string;
|
|
2047
|
+
versionStatus?: number;
|
|
2048
|
+
static names(): {
|
|
2049
|
+
[key: string]: string;
|
|
2050
|
+
};
|
|
2051
|
+
static types(): {
|
|
2052
|
+
[key: string]: any;
|
|
2053
|
+
};
|
|
2054
|
+
constructor(map?: {
|
|
2055
|
+
[key: string]: any;
|
|
2056
|
+
});
|
|
2057
|
+
}
|
|
2058
|
+
export declare class QueryAsyncTaskResponseBodyData extends $tea.Model {
|
|
2059
|
+
createTime?: string;
|
|
2060
|
+
createUser?: string;
|
|
2061
|
+
taskCode?: string;
|
|
2062
|
+
taskErrorMessage?: string;
|
|
2063
|
+
taskId?: string;
|
|
2064
|
+
taskIntermediateResult?: string;
|
|
2065
|
+
taskName?: string;
|
|
2066
|
+
taskParam?: string;
|
|
2067
|
+
taskProgressMessage?: string;
|
|
2068
|
+
taskResult?: string;
|
|
2069
|
+
taskRetryCount?: string;
|
|
2070
|
+
taskStatus?: number;
|
|
2071
|
+
updateTime?: string;
|
|
2072
|
+
updateUser?: string;
|
|
2073
|
+
static names(): {
|
|
2074
|
+
[key: string]: string;
|
|
2075
|
+
};
|
|
2076
|
+
static types(): {
|
|
2077
|
+
[key: string]: any;
|
|
2078
|
+
};
|
|
2079
|
+
constructor(map?: {
|
|
2080
|
+
[key: string]: any;
|
|
2081
|
+
});
|
|
2082
|
+
}
|
|
2083
|
+
export declare class SaveDataSourceOrderConfigRequestUserConfigDataSourceList extends $tea.Model {
|
|
2084
|
+
code?: string;
|
|
2085
|
+
name?: string;
|
|
2086
|
+
number?: number;
|
|
2087
|
+
type?: string;
|
|
2088
|
+
static names(): {
|
|
2089
|
+
[key: string]: string;
|
|
2090
|
+
};
|
|
2091
|
+
static types(): {
|
|
2092
|
+
[key: string]: any;
|
|
2093
|
+
};
|
|
2094
|
+
constructor(map?: {
|
|
2095
|
+
[key: string]: any;
|
|
2096
|
+
});
|
|
2097
|
+
}
|
|
2098
|
+
export declare class SubmitAsyncTaskResponseBodyData extends $tea.Model {
|
|
2099
|
+
taskId?: string;
|
|
2100
|
+
taskIntermediateResult?: any;
|
|
2101
|
+
taskName?: string;
|
|
55
2102
|
static names(): {
|
|
56
2103
|
[key: string]: string;
|
|
57
2104
|
};
|
|
@@ -67,6 +2114,56 @@ export default class Client extends OpenApi {
|
|
|
67
2114
|
getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: {
|
|
68
2115
|
[key: string]: string;
|
|
69
2116
|
}, endpoint: string): string;
|
|
2117
|
+
cancelAsyncTaskWithOptions(request: CancelAsyncTaskRequest, runtime: $Util.RuntimeOptions): Promise<CancelAsyncTaskResponse>;
|
|
2118
|
+
cancelAsyncTask(request: CancelAsyncTaskRequest): Promise<CancelAsyncTaskResponse>;
|
|
2119
|
+
createGeneratedContentWithOptions(tmpReq: CreateGeneratedContentRequest, runtime: $Util.RuntimeOptions): Promise<CreateGeneratedContentResponse>;
|
|
2120
|
+
createGeneratedContent(request: CreateGeneratedContentRequest): Promise<CreateGeneratedContentResponse>;
|
|
70
2121
|
createTokenWithOptions(request: CreateTokenRequest, runtime: $Util.RuntimeOptions): Promise<CreateTokenResponse>;
|
|
71
2122
|
createToken(request: CreateTokenRequest): Promise<CreateTokenResponse>;
|
|
2123
|
+
deleteGeneratedContentWithOptions(request: DeleteGeneratedContentRequest, runtime: $Util.RuntimeOptions): Promise<DeleteGeneratedContentResponse>;
|
|
2124
|
+
deleteGeneratedContent(request: DeleteGeneratedContentRequest): Promise<DeleteGeneratedContentResponse>;
|
|
2125
|
+
deleteMaterialByIdWithOptions(request: DeleteMaterialByIdRequest, runtime: $Util.RuntimeOptions): Promise<DeleteMaterialByIdResponse>;
|
|
2126
|
+
deleteMaterialById(request: DeleteMaterialByIdRequest): Promise<DeleteMaterialByIdResponse>;
|
|
2127
|
+
exportGeneratedContentWithOptions(request: ExportGeneratedContentRequest, runtime: $Util.RuntimeOptions): Promise<ExportGeneratedContentResponse>;
|
|
2128
|
+
exportGeneratedContent(request: ExportGeneratedContentRequest): Promise<ExportGeneratedContentResponse>;
|
|
2129
|
+
feedbackDialogueWithOptions(tmpReq: FeedbackDialogueRequest, runtime: $Util.RuntimeOptions): Promise<FeedbackDialogueResponse>;
|
|
2130
|
+
feedbackDialogue(request: FeedbackDialogueRequest): Promise<FeedbackDialogueResponse>;
|
|
2131
|
+
fetchImageTaskWithOptions(tmpReq: FetchImageTaskRequest, runtime: $Util.RuntimeOptions): Promise<FetchImageTaskResponse>;
|
|
2132
|
+
fetchImageTask(request: FetchImageTaskRequest): Promise<FetchImageTaskResponse>;
|
|
2133
|
+
generateImageTaskWithOptions(tmpReq: GenerateImageTaskRequest, runtime: $Util.RuntimeOptions): Promise<GenerateImageTaskResponse>;
|
|
2134
|
+
generateImageTask(request: GenerateImageTaskRequest): Promise<GenerateImageTaskResponse>;
|
|
2135
|
+
generateViewPointWithOptions(tmpReq: GenerateViewPointRequest, runtime: $Util.RuntimeOptions): Promise<GenerateViewPointResponse>;
|
|
2136
|
+
generateViewPoint(request: GenerateViewPointRequest): Promise<GenerateViewPointResponse>;
|
|
2137
|
+
getDataSourceOrderConfigWithOptions(request: GetDataSourceOrderConfigRequest, runtime: $Util.RuntimeOptions): Promise<GetDataSourceOrderConfigResponse>;
|
|
2138
|
+
getDataSourceOrderConfig(request: GetDataSourceOrderConfigRequest): Promise<GetDataSourceOrderConfigResponse>;
|
|
2139
|
+
getGeneratedContentWithOptions(request: GetGeneratedContentRequest, runtime: $Util.RuntimeOptions): Promise<GetGeneratedContentResponse>;
|
|
2140
|
+
getGeneratedContent(request: GetGeneratedContentRequest): Promise<GetGeneratedContentResponse>;
|
|
2141
|
+
getMaterialByIdWithOptions(request: GetMaterialByIdRequest, runtime: $Util.RuntimeOptions): Promise<GetMaterialByIdResponse>;
|
|
2142
|
+
getMaterialById(request: GetMaterialByIdRequest): Promise<GetMaterialByIdResponse>;
|
|
2143
|
+
getPropertiesWithOptions(request: GetPropertiesRequest, runtime: $Util.RuntimeOptions): Promise<GetPropertiesResponse>;
|
|
2144
|
+
getProperties(request: GetPropertiesRequest): Promise<GetPropertiesResponse>;
|
|
2145
|
+
listAsyncTasksWithOptions(tmpReq: ListAsyncTasksRequest, runtime: $Util.RuntimeOptions): Promise<ListAsyncTasksResponse>;
|
|
2146
|
+
listAsyncTasks(request: ListAsyncTasksRequest): Promise<ListAsyncTasksResponse>;
|
|
2147
|
+
listBuildConfigsWithOptions(request: ListBuildConfigsRequest, runtime: $Util.RuntimeOptions): Promise<ListBuildConfigsResponse>;
|
|
2148
|
+
listBuildConfigs(request: ListBuildConfigsRequest): Promise<ListBuildConfigsResponse>;
|
|
2149
|
+
listDialoguesWithOptions(request: ListDialoguesRequest, runtime: $Util.RuntimeOptions): Promise<ListDialoguesResponse>;
|
|
2150
|
+
listDialogues(request: ListDialoguesRequest): Promise<ListDialoguesResponse>;
|
|
2151
|
+
listGeneratedContentsWithOptions(request: ListGeneratedContentsRequest, runtime: $Util.RuntimeOptions): Promise<ListGeneratedContentsResponse>;
|
|
2152
|
+
listGeneratedContents(request: ListGeneratedContentsRequest): Promise<ListGeneratedContentsResponse>;
|
|
2153
|
+
listHotNewsWithTypeWithOptions(tmpReq: ListHotNewsWithTypeRequest, runtime: $Util.RuntimeOptions): Promise<ListHotNewsWithTypeResponse>;
|
|
2154
|
+
listHotNewsWithType(request: ListHotNewsWithTypeRequest): Promise<ListHotNewsWithTypeResponse>;
|
|
2155
|
+
listMaterialDocumentsWithOptions(tmpReq: ListMaterialDocumentsRequest, runtime: $Util.RuntimeOptions): Promise<ListMaterialDocumentsResponse>;
|
|
2156
|
+
listMaterialDocuments(request: ListMaterialDocumentsRequest): Promise<ListMaterialDocumentsResponse>;
|
|
2157
|
+
listVersionsWithOptions(request: ListVersionsRequest, runtime: $Util.RuntimeOptions): Promise<ListVersionsResponse>;
|
|
2158
|
+
listVersions(request: ListVersionsRequest): Promise<ListVersionsResponse>;
|
|
2159
|
+
queryAsyncTaskWithOptions(request: QueryAsyncTaskRequest, runtime: $Util.RuntimeOptions): Promise<QueryAsyncTaskResponse>;
|
|
2160
|
+
queryAsyncTask(request: QueryAsyncTaskRequest): Promise<QueryAsyncTaskResponse>;
|
|
2161
|
+
saveDataSourceOrderConfigWithOptions(tmpReq: SaveDataSourceOrderConfigRequest, runtime: $Util.RuntimeOptions): Promise<SaveDataSourceOrderConfigResponse>;
|
|
2162
|
+
saveDataSourceOrderConfig(request: SaveDataSourceOrderConfigRequest): Promise<SaveDataSourceOrderConfigResponse>;
|
|
2163
|
+
saveMaterialDocumentWithOptions(tmpReq: SaveMaterialDocumentRequest, runtime: $Util.RuntimeOptions): Promise<SaveMaterialDocumentResponse>;
|
|
2164
|
+
saveMaterialDocument(request: SaveMaterialDocumentRequest): Promise<SaveMaterialDocumentResponse>;
|
|
2165
|
+
submitAsyncTaskWithOptions(request: SubmitAsyncTaskRequest, runtime: $Util.RuntimeOptions): Promise<SubmitAsyncTaskResponse>;
|
|
2166
|
+
submitAsyncTask(request: SubmitAsyncTaskRequest): Promise<SubmitAsyncTaskResponse>;
|
|
2167
|
+
updateMaterialDocumentWithOptions(tmpReq: UpdateMaterialDocumentRequest, runtime: $Util.RuntimeOptions): Promise<UpdateMaterialDocumentResponse>;
|
|
2168
|
+
updateMaterialDocument(request: UpdateMaterialDocumentRequest): Promise<UpdateMaterialDocumentResponse>;
|
|
72
2169
|
}
|