szpt-driver-api 1.0.1
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/_request.d.ts +7 -0
- package/accident.d.ts +2539 -0
- package/accident.js +2 -0
- package/accident.js.map +1 -0
- package/auth.d.ts +4301 -0
- package/auth.js +2 -0
- package/auth.js.map +1 -0
- package/authBpmn.d.ts +2350 -0
- package/authBpmn.js +2 -0
- package/authBpmn.js.map +1 -0
- package/authBpmnQuery.d.ts +2873 -0
- package/authBpmnQuery.js +2 -0
- package/authBpmnQuery.js.map +1 -0
- package/common.d.ts +1205 -0
- package/common.js +2 -0
- package/common.js.map +1 -0
- package/index.d.ts +7 -0
- package/index.js +2 -0
- package/index.js.map +1 -0
- package/oss.d.ts +313 -0
- package/oss.js +2 -0
- package/oss.js.map +1 -0
- package/package.json +17 -0
|
@@ -0,0 +1,2873 @@
|
|
|
1
|
+
export declare class CacheStatsInfo {
|
|
2
|
+
averageLoadPenalty: Number;
|
|
3
|
+
evictionCount: Number;
|
|
4
|
+
hitCount: Number;
|
|
5
|
+
hitRate: Number;
|
|
6
|
+
loadCount: Number;
|
|
7
|
+
loadExceptionCount: Number;
|
|
8
|
+
loadExceptionRate: Number;
|
|
9
|
+
loadSuccessCount: Number;
|
|
10
|
+
missCount: Number;
|
|
11
|
+
missRate: Number;
|
|
12
|
+
requestCount: Number;
|
|
13
|
+
totalLoadTime: Number;
|
|
14
|
+
}
|
|
15
|
+
export declare class CountData {
|
|
16
|
+
/** @format int32 */
|
|
17
|
+
count: number;
|
|
18
|
+
/** @format int64 */
|
|
19
|
+
time: number;
|
|
20
|
+
}
|
|
21
|
+
export declare class DeleteRedisRecordRequest {
|
|
22
|
+
/** 流程KEY */
|
|
23
|
+
processDefinitionKey?: string;
|
|
24
|
+
/** 流程Id */
|
|
25
|
+
processId?: string;
|
|
26
|
+
/** 任务节点KEY */
|
|
27
|
+
taskDefinitionKey?: string;
|
|
28
|
+
/** 任务节点 */
|
|
29
|
+
taskId?: string;
|
|
30
|
+
/** 用户名 */
|
|
31
|
+
username?: string;
|
|
32
|
+
}
|
|
33
|
+
export declare class DroppedEventEntity {
|
|
34
|
+
deleted: boolean;
|
|
35
|
+
error: string;
|
|
36
|
+
eventContent: string;
|
|
37
|
+
/** @format int64 */
|
|
38
|
+
id: number;
|
|
39
|
+
/** @format int32 */
|
|
40
|
+
retryTimes: number;
|
|
41
|
+
stream: string;
|
|
42
|
+
/** @format int64 */
|
|
43
|
+
time: number;
|
|
44
|
+
}
|
|
45
|
+
export declare class Duration {
|
|
46
|
+
/** @format int32 */
|
|
47
|
+
nano: number;
|
|
48
|
+
negative: boolean;
|
|
49
|
+
/** @format int64 */
|
|
50
|
+
seconds: number;
|
|
51
|
+
units: TemporalUnit[];
|
|
52
|
+
zero: boolean;
|
|
53
|
+
}
|
|
54
|
+
export declare class FindRedisRecordRequest {
|
|
55
|
+
/** 流程KEY */
|
|
56
|
+
processDefinitionKey?: string;
|
|
57
|
+
/** 任务节点KEY */
|
|
58
|
+
taskDefinitionKey?: string;
|
|
59
|
+
/** 用户名 */
|
|
60
|
+
username?: string;
|
|
61
|
+
}
|
|
62
|
+
export declare class FindRedisRecordResponse {
|
|
63
|
+
/** 流程Id */
|
|
64
|
+
processSet: string[];
|
|
65
|
+
/** 任务Id */
|
|
66
|
+
taskSet: string[];
|
|
67
|
+
}
|
|
68
|
+
export declare class Form {
|
|
69
|
+
code: string;
|
|
70
|
+
deleted: boolean;
|
|
71
|
+
fields: FormField[];
|
|
72
|
+
/** @format int64 */
|
|
73
|
+
id: number;
|
|
74
|
+
name: string;
|
|
75
|
+
properties: string;
|
|
76
|
+
rel: string;
|
|
77
|
+
}
|
|
78
|
+
export declare class FormField {
|
|
79
|
+
arrayType: string;
|
|
80
|
+
complexForm: Form;
|
|
81
|
+
complexFormCode: string;
|
|
82
|
+
default: any;
|
|
83
|
+
deleted: boolean;
|
|
84
|
+
description: string;
|
|
85
|
+
hidden: boolean;
|
|
86
|
+
/** @format int64 */
|
|
87
|
+
id: number;
|
|
88
|
+
/** @format int32 */
|
|
89
|
+
index: number;
|
|
90
|
+
/** @format double */
|
|
91
|
+
max: number;
|
|
92
|
+
/** @format double */
|
|
93
|
+
min: number;
|
|
94
|
+
name: string;
|
|
95
|
+
options: string;
|
|
96
|
+
properties: string;
|
|
97
|
+
regex: string;
|
|
98
|
+
required: boolean;
|
|
99
|
+
tags: string[];
|
|
100
|
+
title: string;
|
|
101
|
+
type: string;
|
|
102
|
+
value: any;
|
|
103
|
+
valueType: string;
|
|
104
|
+
}
|
|
105
|
+
export declare class IntegrationContext {
|
|
106
|
+
businessKey: string;
|
|
107
|
+
clientId: string;
|
|
108
|
+
clientName: string;
|
|
109
|
+
clientType: string;
|
|
110
|
+
connectorType: string;
|
|
111
|
+
errorClassName: string;
|
|
112
|
+
errorCode: string;
|
|
113
|
+
/** @format int64 */
|
|
114
|
+
errorDate: number;
|
|
115
|
+
errorMessage: string;
|
|
116
|
+
executionId: string;
|
|
117
|
+
id: string;
|
|
118
|
+
inBoundVariables: any;
|
|
119
|
+
outBoundVariables: any;
|
|
120
|
+
parentProcessInstanceId: string;
|
|
121
|
+
processDefinitionId: string;
|
|
122
|
+
processDefinitionKey: string;
|
|
123
|
+
/** @format int32 */
|
|
124
|
+
processDefinitionVersion: number;
|
|
125
|
+
processInstanceId: string;
|
|
126
|
+
/** @format int64 */
|
|
127
|
+
requestDate: number;
|
|
128
|
+
/** @format int64 */
|
|
129
|
+
resultDate: number;
|
|
130
|
+
status: "INTEGRATION_ERROR_RECEIVED" | "INTEGRATION_REQUESTED" | "INTEGRATION_RESULT_RECEIVED";
|
|
131
|
+
}
|
|
132
|
+
export declare type Number = any;
|
|
133
|
+
export declare class PageResultDroppedEventEntity {
|
|
134
|
+
list: DroppedEventEntity[];
|
|
135
|
+
/** @format int64 */
|
|
136
|
+
total: number;
|
|
137
|
+
}
|
|
138
|
+
export declare class PageResultIntegrationContext {
|
|
139
|
+
list: IntegrationContext[];
|
|
140
|
+
/** @format int64 */
|
|
141
|
+
total: number;
|
|
142
|
+
}
|
|
143
|
+
export declare class PageResultProcessDTO {
|
|
144
|
+
list: ProcessDTO[];
|
|
145
|
+
/** @format int64 */
|
|
146
|
+
total: number;
|
|
147
|
+
}
|
|
148
|
+
export declare class PageResultProcessTaskWithProcessInfo {
|
|
149
|
+
list: ProcessTaskWithProcessInfo[];
|
|
150
|
+
/** @format int64 */
|
|
151
|
+
total: number;
|
|
152
|
+
}
|
|
153
|
+
export declare class PageResultSubscribeRule {
|
|
154
|
+
list: SubscribeRuleRes[];
|
|
155
|
+
/** @format int64 */
|
|
156
|
+
total: number;
|
|
157
|
+
}
|
|
158
|
+
export declare class ProcessDTO {
|
|
159
|
+
/** 业务id */
|
|
160
|
+
businessKey: string;
|
|
161
|
+
/** 流程撤销人 */
|
|
162
|
+
cancelBy: string;
|
|
163
|
+
/** 流程撤销原因 */
|
|
164
|
+
cancelReason: string;
|
|
165
|
+
/**
|
|
166
|
+
* 是否已经取消
|
|
167
|
+
* @example false
|
|
168
|
+
*/
|
|
169
|
+
canceled: boolean;
|
|
170
|
+
/** 流程类型 */
|
|
171
|
+
category: string;
|
|
172
|
+
/** 抄送人列表 */
|
|
173
|
+
ccTo: string[];
|
|
174
|
+
/**
|
|
175
|
+
* 是否已经完成
|
|
176
|
+
* @example false
|
|
177
|
+
*/
|
|
178
|
+
complete: boolean;
|
|
179
|
+
/** 流程关联部门 */
|
|
180
|
+
department: string;
|
|
181
|
+
/**
|
|
182
|
+
* 结束时间
|
|
183
|
+
* @format int64
|
|
184
|
+
* @example 16480246278910
|
|
185
|
+
*/
|
|
186
|
+
endTime: number;
|
|
187
|
+
/** 流程表单结构 */
|
|
188
|
+
form: Form;
|
|
189
|
+
/** 流程表单code */
|
|
190
|
+
formCode: string;
|
|
191
|
+
/** 流程表单数据 */
|
|
192
|
+
formData: any;
|
|
193
|
+
/** 流程id */
|
|
194
|
+
id: string;
|
|
195
|
+
/** 流程名称 */
|
|
196
|
+
name: string;
|
|
197
|
+
/** 流程模版id */
|
|
198
|
+
processDefinitionId: string;
|
|
199
|
+
/** 流程模版key */
|
|
200
|
+
processDefinitionKey: string;
|
|
201
|
+
/** 流程模版名称 */
|
|
202
|
+
processDefinitionName: string;
|
|
203
|
+
/** 发起人 */
|
|
204
|
+
startBy: string;
|
|
205
|
+
/**
|
|
206
|
+
* 启动时间
|
|
207
|
+
* @format int64
|
|
208
|
+
* @example 16480246278910
|
|
209
|
+
*/
|
|
210
|
+
startTime: number;
|
|
211
|
+
/** 流程状态 */
|
|
212
|
+
status: "CANCELLED" | "COMPLETED" | "CREATED" | "RUNNING" | "SUSPENDED";
|
|
213
|
+
/**
|
|
214
|
+
* 是否暂停或中断
|
|
215
|
+
* @example false
|
|
216
|
+
*/
|
|
217
|
+
suspended: boolean;
|
|
218
|
+
/** 用户任务已读情况 */
|
|
219
|
+
taskReads: Record<string, ReadRecord[]>;
|
|
220
|
+
/** 流程节点列表 */
|
|
221
|
+
tasks: ProcessTask[];
|
|
222
|
+
/** 同业务id(兼容性字段) */
|
|
223
|
+
uid: string;
|
|
224
|
+
}
|
|
225
|
+
export declare class ProcessSubscribeRule {
|
|
226
|
+
processDefinitionKey: string;
|
|
227
|
+
taskDefinitionKeys: string[];
|
|
228
|
+
}
|
|
229
|
+
export declare class ProcessTask {
|
|
230
|
+
/**
|
|
231
|
+
* 是否处于激活状态(兼容性字段)
|
|
232
|
+
* @example false
|
|
233
|
+
*/
|
|
234
|
+
active: boolean;
|
|
235
|
+
/** 节点处理人 */
|
|
236
|
+
assignee: string;
|
|
237
|
+
/** 节点附件信息 */
|
|
238
|
+
attachments: ProcessTaskAttachment[];
|
|
239
|
+
/** 节点候选人列表 */
|
|
240
|
+
candidateUsers: string[];
|
|
241
|
+
/** 节点评论信息 */
|
|
242
|
+
comments: ProcessTaskComment[];
|
|
243
|
+
/**
|
|
244
|
+
* 是否已结束(兼容性字段)
|
|
245
|
+
* @example false
|
|
246
|
+
*/
|
|
247
|
+
completed: boolean;
|
|
248
|
+
/**
|
|
249
|
+
* 是否已删除(兼容性字段)
|
|
250
|
+
* @example false
|
|
251
|
+
*/
|
|
252
|
+
deleted: boolean;
|
|
253
|
+
/** 运行时长(兼容性字段) */
|
|
254
|
+
duration: Duration;
|
|
255
|
+
/**
|
|
256
|
+
* 节点结束时间(兼容性字段)
|
|
257
|
+
* @format int64
|
|
258
|
+
* @example 16480246278910
|
|
259
|
+
*/
|
|
260
|
+
endAt: number;
|
|
261
|
+
/**
|
|
262
|
+
* 节点结束时间
|
|
263
|
+
* @format int64
|
|
264
|
+
* @example 16480246278910
|
|
265
|
+
*/
|
|
266
|
+
endTime: number;
|
|
267
|
+
/** 错误信息 */
|
|
268
|
+
errors: TaskError[];
|
|
269
|
+
/** 流程执行id */
|
|
270
|
+
executionId: string;
|
|
271
|
+
/** 节点表单结构 */
|
|
272
|
+
form: Form;
|
|
273
|
+
/** 节点表单Code */
|
|
274
|
+
formCode: string;
|
|
275
|
+
/** 节点表单数据 */
|
|
276
|
+
formData: any;
|
|
277
|
+
/** 节点id */
|
|
278
|
+
id: string;
|
|
279
|
+
/** 节点名称 */
|
|
280
|
+
name: string;
|
|
281
|
+
/** 流程业务id */
|
|
282
|
+
processBusinessKey: string;
|
|
283
|
+
/** 流程id */
|
|
284
|
+
processInstanceId: string;
|
|
285
|
+
/** 同流程业务id(兼容性字段) */
|
|
286
|
+
processUid: string;
|
|
287
|
+
/** 节点返回表单结构(仅适用于服务任务类节点) */
|
|
288
|
+
resultForm: Form;
|
|
289
|
+
/** 节点返回表单数据(仅适用于服务任务类节点) */
|
|
290
|
+
resultFormCode: string;
|
|
291
|
+
/** 节点返回表单数据(仅适用于服务任务类节点) */
|
|
292
|
+
resultFormData: any;
|
|
293
|
+
/**
|
|
294
|
+
* 节点开始时间(兼容性字段)
|
|
295
|
+
* @format int64
|
|
296
|
+
* @example 16480246278910
|
|
297
|
+
*/
|
|
298
|
+
startAt: number;
|
|
299
|
+
/**
|
|
300
|
+
* 节点开始时间
|
|
301
|
+
* @format int64
|
|
302
|
+
* @example 16480246278910
|
|
303
|
+
*/
|
|
304
|
+
startTime: number;
|
|
305
|
+
/**
|
|
306
|
+
* 是否已开始(兼容性字段)
|
|
307
|
+
* @example false
|
|
308
|
+
*/
|
|
309
|
+
started: boolean;
|
|
310
|
+
/** 节点状态 */
|
|
311
|
+
status: "ASSIGNED" | "CANCELLED" | "COMPLETED" | "CREATED" | "DELETED" | "SUSPENDED";
|
|
312
|
+
/** 节点子任务列表 */
|
|
313
|
+
subTaskList: ProcessTask[];
|
|
314
|
+
/**
|
|
315
|
+
* 是否处于中断状态(兼容性字段)
|
|
316
|
+
* @example false
|
|
317
|
+
*/
|
|
318
|
+
suspended: boolean;
|
|
319
|
+
/** 节点定义key */
|
|
320
|
+
taskDefinitionKey: string;
|
|
321
|
+
/** 任务id */
|
|
322
|
+
taskId: string;
|
|
323
|
+
/** 节点类型 */
|
|
324
|
+
type: string;
|
|
325
|
+
}
|
|
326
|
+
export declare class ProcessTaskAttachment {
|
|
327
|
+
description: string;
|
|
328
|
+
id: string;
|
|
329
|
+
name: string;
|
|
330
|
+
taskId: string;
|
|
331
|
+
/** @format int64 */
|
|
332
|
+
time: number;
|
|
333
|
+
type: string;
|
|
334
|
+
url: string;
|
|
335
|
+
user: string;
|
|
336
|
+
}
|
|
337
|
+
export declare class ProcessTaskComment {
|
|
338
|
+
id: string;
|
|
339
|
+
message: string;
|
|
340
|
+
taskId: string;
|
|
341
|
+
/** @format int64 */
|
|
342
|
+
time: number;
|
|
343
|
+
user: string;
|
|
344
|
+
}
|
|
345
|
+
export declare class ProcessTaskWithProcessInfo {
|
|
346
|
+
/**
|
|
347
|
+
* 是否处于激活状态(兼容性字段)
|
|
348
|
+
* @example false
|
|
349
|
+
*/
|
|
350
|
+
active: boolean;
|
|
351
|
+
/** 节点处理人 */
|
|
352
|
+
assignee: string;
|
|
353
|
+
/** 节点附件信息 */
|
|
354
|
+
attachments: ProcessTaskAttachment[];
|
|
355
|
+
/** 节点候选人列表 */
|
|
356
|
+
candidateUsers: string[];
|
|
357
|
+
/** 节点评论信息 */
|
|
358
|
+
comments: ProcessTaskComment[];
|
|
359
|
+
/**
|
|
360
|
+
* 是否已结束(兼容性字段)
|
|
361
|
+
* @example false
|
|
362
|
+
*/
|
|
363
|
+
completed: boolean;
|
|
364
|
+
/**
|
|
365
|
+
* 是否已删除(兼容性字段)
|
|
366
|
+
* @example false
|
|
367
|
+
*/
|
|
368
|
+
deleted: boolean;
|
|
369
|
+
/** 流程关联部门 */
|
|
370
|
+
department: string;
|
|
371
|
+
/** 运行时长(兼容性字段) */
|
|
372
|
+
duration: Duration;
|
|
373
|
+
/**
|
|
374
|
+
* 节点结束时间(兼容性字段)
|
|
375
|
+
* @format int64
|
|
376
|
+
* @example 16480246278910
|
|
377
|
+
*/
|
|
378
|
+
endAt: number;
|
|
379
|
+
/**
|
|
380
|
+
* 节点结束时间
|
|
381
|
+
* @format int64
|
|
382
|
+
* @example 16480246278910
|
|
383
|
+
*/
|
|
384
|
+
endTime: number;
|
|
385
|
+
/** 错误信息 */
|
|
386
|
+
errors: TaskError[];
|
|
387
|
+
/** 流程执行id */
|
|
388
|
+
executionId: string;
|
|
389
|
+
/** 节点表单结构 */
|
|
390
|
+
form: Form;
|
|
391
|
+
/** 节点表单Code */
|
|
392
|
+
formCode: string;
|
|
393
|
+
/** 节点表单数据 */
|
|
394
|
+
formData: any;
|
|
395
|
+
/** 节点id */
|
|
396
|
+
id: string;
|
|
397
|
+
/** 节点名称 */
|
|
398
|
+
name: string;
|
|
399
|
+
/** 流程业务id */
|
|
400
|
+
processBusinessKey: string;
|
|
401
|
+
/** 流程类型 */
|
|
402
|
+
processCategory: string;
|
|
403
|
+
/** 流程模版id */
|
|
404
|
+
processDefinitionId: string;
|
|
405
|
+
/** 流程模版key */
|
|
406
|
+
processDefinitionKey: string;
|
|
407
|
+
/** 流程表单数据 */
|
|
408
|
+
processFormData: any;
|
|
409
|
+
/** 流程启动用户 */
|
|
410
|
+
processInitiator: string;
|
|
411
|
+
/** 流程id */
|
|
412
|
+
processInstanceId: string;
|
|
413
|
+
/** 流程名称 */
|
|
414
|
+
processName: string;
|
|
415
|
+
/**
|
|
416
|
+
* 流程启动时间
|
|
417
|
+
* @format int64
|
|
418
|
+
* @example 16480246278910
|
|
419
|
+
*/
|
|
420
|
+
processStartDate: number;
|
|
421
|
+
/** 流程状态 */
|
|
422
|
+
processStatus: "CANCELLED" | "COMPLETED" | "CREATED" | "RUNNING" | "SUSPENDED";
|
|
423
|
+
/** 同流程业务id(兼容性字段) */
|
|
424
|
+
processUid: string;
|
|
425
|
+
/** 已读人员列表 */
|
|
426
|
+
reads: ReadRecord[];
|
|
427
|
+
/** 节点返回表单结构(仅适用于服务任务类节点) */
|
|
428
|
+
resultForm: Form;
|
|
429
|
+
/** 节点返回表单数据(仅适用于服务任务类节点) */
|
|
430
|
+
resultFormCode: string;
|
|
431
|
+
/** 节点返回表单数据(仅适用于服务任务类节点) */
|
|
432
|
+
resultFormData: any;
|
|
433
|
+
/**
|
|
434
|
+
* 节点开始时间(兼容性字段)
|
|
435
|
+
* @format int64
|
|
436
|
+
* @example 16480246278910
|
|
437
|
+
*/
|
|
438
|
+
startAt: number;
|
|
439
|
+
/**
|
|
440
|
+
* 节点开始时间
|
|
441
|
+
* @format int64
|
|
442
|
+
* @example 16480246278910
|
|
443
|
+
*/
|
|
444
|
+
startTime: number;
|
|
445
|
+
/**
|
|
446
|
+
* 是否已开始(兼容性字段)
|
|
447
|
+
* @example false
|
|
448
|
+
*/
|
|
449
|
+
started: boolean;
|
|
450
|
+
/** 节点状态 */
|
|
451
|
+
status: "ASSIGNED" | "CANCELLED" | "COMPLETED" | "CREATED" | "DELETED" | "SUSPENDED";
|
|
452
|
+
/** 节点子任务列表 */
|
|
453
|
+
subTaskList: ProcessTask[];
|
|
454
|
+
/**
|
|
455
|
+
* 是否处于中断状态(兼容性字段)
|
|
456
|
+
* @example false
|
|
457
|
+
*/
|
|
458
|
+
suspended: boolean;
|
|
459
|
+
/** 节点定义key */
|
|
460
|
+
taskDefinitionKey: string;
|
|
461
|
+
/** 任务id */
|
|
462
|
+
taskId: string;
|
|
463
|
+
/** 节点类型 */
|
|
464
|
+
type: string;
|
|
465
|
+
}
|
|
466
|
+
export declare class QueryCountResponse {
|
|
467
|
+
/**
|
|
468
|
+
* 数量
|
|
469
|
+
* @format int32
|
|
470
|
+
*/
|
|
471
|
+
count: number;
|
|
472
|
+
/** 各个任务 */
|
|
473
|
+
detail: Record<string, number>[];
|
|
474
|
+
/** 用户名 */
|
|
475
|
+
user: string;
|
|
476
|
+
}
|
|
477
|
+
export declare class QueryDepartmentCountResponse {
|
|
478
|
+
/**
|
|
479
|
+
* 数量
|
|
480
|
+
* @format int32
|
|
481
|
+
*/
|
|
482
|
+
count: number;
|
|
483
|
+
/** 部门代码 */
|
|
484
|
+
department: string;
|
|
485
|
+
}
|
|
486
|
+
export declare class QueryMultipleTaskCountByDeptRequest {
|
|
487
|
+
/** 部门代码列表 */
|
|
488
|
+
departments?: string[];
|
|
489
|
+
/** 任务标识 */
|
|
490
|
+
tasks?: TaskSpecific[];
|
|
491
|
+
}
|
|
492
|
+
export declare class QueryMultipleTaskCountRequest {
|
|
493
|
+
/** 任务标识 */
|
|
494
|
+
tasks?: TaskSpecific[];
|
|
495
|
+
/** 用户名列表 */
|
|
496
|
+
users?: string[];
|
|
497
|
+
}
|
|
498
|
+
export declare class QuerySingleTaskCountByDeptRequest {
|
|
499
|
+
/** 部门代码列表 */
|
|
500
|
+
departments?: string[];
|
|
501
|
+
/** 任务标识 */
|
|
502
|
+
task?: TaskSpecific;
|
|
503
|
+
}
|
|
504
|
+
export declare class QuerySingleTaskCountRequest {
|
|
505
|
+
/** 任务标识 */
|
|
506
|
+
task?: TaskSpecific;
|
|
507
|
+
/** 用户名列表 */
|
|
508
|
+
users?: string[];
|
|
509
|
+
}
|
|
510
|
+
export declare class ReadRecord {
|
|
511
|
+
/**
|
|
512
|
+
* 已读时间
|
|
513
|
+
* @format int64
|
|
514
|
+
*/
|
|
515
|
+
time: number;
|
|
516
|
+
/** 用户名 */
|
|
517
|
+
username: string;
|
|
518
|
+
}
|
|
519
|
+
export declare class SubscribeRuleReq {
|
|
520
|
+
department?: string;
|
|
521
|
+
enable?: boolean;
|
|
522
|
+
excludeUsers?: string[];
|
|
523
|
+
id?: string;
|
|
524
|
+
includeSubDepartment?: boolean;
|
|
525
|
+
includeUsers?: string[];
|
|
526
|
+
permission?: string;
|
|
527
|
+
policeType?: string;
|
|
528
|
+
processDefinitions?: ProcessSubscribeRule[];
|
|
529
|
+
processDepartments?: string[];
|
|
530
|
+
roleName?: string;
|
|
531
|
+
title?: string;
|
|
532
|
+
}
|
|
533
|
+
export declare class SubscribeRuleRes {
|
|
534
|
+
department: string;
|
|
535
|
+
enable: boolean;
|
|
536
|
+
excludeUsers: string[];
|
|
537
|
+
id: string;
|
|
538
|
+
includeSubDepartment: boolean;
|
|
539
|
+
includeUsers: string[];
|
|
540
|
+
permission: string;
|
|
541
|
+
policeType: string;
|
|
542
|
+
processDefinitions: ProcessSubscribeRule[];
|
|
543
|
+
processDepartments: string[];
|
|
544
|
+
roleName: string;
|
|
545
|
+
title: string;
|
|
546
|
+
}
|
|
547
|
+
export declare class TaskError {
|
|
548
|
+
/** 错误码 */
|
|
549
|
+
code: string;
|
|
550
|
+
/** 流程任务标识 */
|
|
551
|
+
connectorType: string;
|
|
552
|
+
/** 错误提示信息 */
|
|
553
|
+
message: string;
|
|
554
|
+
/**
|
|
555
|
+
* 错误发生时间
|
|
556
|
+
* @format int64
|
|
557
|
+
* @example 16480246278910
|
|
558
|
+
*/
|
|
559
|
+
time: number;
|
|
560
|
+
}
|
|
561
|
+
export declare class TaskSpecific {
|
|
562
|
+
/** 流程KEY */
|
|
563
|
+
processDefinitionKey?: string;
|
|
564
|
+
/** 任务节点KEY */
|
|
565
|
+
taskDefinitionKey?: string;
|
|
566
|
+
}
|
|
567
|
+
export declare class TemporalUnit {
|
|
568
|
+
dateBased: boolean;
|
|
569
|
+
duration: Duration;
|
|
570
|
+
durationEstimated: boolean;
|
|
571
|
+
timeBased: boolean;
|
|
572
|
+
}
|
|
573
|
+
export declare class DroppedEventParams {
|
|
574
|
+
/** 是否删除 */
|
|
575
|
+
deleted?: boolean;
|
|
576
|
+
/** ID */
|
|
577
|
+
id?: string;
|
|
578
|
+
orderBy?: string[];
|
|
579
|
+
/** @format int32 */
|
|
580
|
+
pageIndex?: number;
|
|
581
|
+
/** @format int32 */
|
|
582
|
+
pageSize?: number;
|
|
583
|
+
/**
|
|
584
|
+
* 时间起始
|
|
585
|
+
* @format int64
|
|
586
|
+
*/
|
|
587
|
+
timeBegin?: number;
|
|
588
|
+
/**
|
|
589
|
+
* 时间截止
|
|
590
|
+
* @format int64
|
|
591
|
+
*/
|
|
592
|
+
timeEnd?: number;
|
|
593
|
+
}
|
|
594
|
+
export declare class DroppedEventRecoverParams {
|
|
595
|
+
/**
|
|
596
|
+
* begin
|
|
597
|
+
* @format int64
|
|
598
|
+
*/
|
|
599
|
+
begin?: number;
|
|
600
|
+
/**
|
|
601
|
+
* end
|
|
602
|
+
* @format int64
|
|
603
|
+
*/
|
|
604
|
+
end?: number;
|
|
605
|
+
}
|
|
606
|
+
export declare class IntegrationContextParams {
|
|
607
|
+
/** 业务ID。等同于UID */
|
|
608
|
+
businessKey?: string;
|
|
609
|
+
/** 服务任务节点KEY */
|
|
610
|
+
clientId?: string;
|
|
611
|
+
/** 服务任务类型 */
|
|
612
|
+
connectorType?: string;
|
|
613
|
+
/** ID */
|
|
614
|
+
id?: string;
|
|
615
|
+
orderBy?: string[];
|
|
616
|
+
/** @format int32 */
|
|
617
|
+
pageIndex?: number;
|
|
618
|
+
/** @format int32 */
|
|
619
|
+
pageSize?: number;
|
|
620
|
+
/** 流程模版KEY */
|
|
621
|
+
processDefinitionKey?: string;
|
|
622
|
+
/** 流程模版ID */
|
|
623
|
+
processInstanceId?: string;
|
|
624
|
+
/** 状态 */
|
|
625
|
+
status?: string[];
|
|
626
|
+
/**
|
|
627
|
+
* 时间起始
|
|
628
|
+
* @format int64
|
|
629
|
+
*/
|
|
630
|
+
timeBegin?: number;
|
|
631
|
+
/**
|
|
632
|
+
* 时间截止
|
|
633
|
+
* @format int64
|
|
634
|
+
*/
|
|
635
|
+
timeEnd?: number;
|
|
636
|
+
}
|
|
637
|
+
export declare class HistoryCumulateCountParams {
|
|
638
|
+
/** day */
|
|
639
|
+
day: string;
|
|
640
|
+
/**
|
|
641
|
+
* count
|
|
642
|
+
* @format int64
|
|
643
|
+
*/
|
|
644
|
+
count?: number;
|
|
645
|
+
}
|
|
646
|
+
export declare class HistoryWaitingCountParams {
|
|
647
|
+
/** day */
|
|
648
|
+
day: string;
|
|
649
|
+
/**
|
|
650
|
+
* count
|
|
651
|
+
* @format int64
|
|
652
|
+
*/
|
|
653
|
+
count?: number;
|
|
654
|
+
}
|
|
655
|
+
export declare class DoMigrationParams {
|
|
656
|
+
/**
|
|
657
|
+
* size
|
|
658
|
+
* @format int32
|
|
659
|
+
*/
|
|
660
|
+
size: number;
|
|
661
|
+
/** delete */
|
|
662
|
+
delete: boolean;
|
|
663
|
+
}
|
|
664
|
+
export declare class MigrationClearScheduleToggleParams {
|
|
665
|
+
/** open */
|
|
666
|
+
open?: boolean;
|
|
667
|
+
}
|
|
668
|
+
export declare class MigrationScheduleToggleParams {
|
|
669
|
+
/** open */
|
|
670
|
+
open?: boolean;
|
|
671
|
+
}
|
|
672
|
+
export declare class ProcessParams {
|
|
673
|
+
/** 业务ID。等同于UID */
|
|
674
|
+
businessKey?: string;
|
|
675
|
+
/** 流程撤销人。支持多选 */
|
|
676
|
+
cancelUser?: string[];
|
|
677
|
+
/** 抄送人。不支持多选 */
|
|
678
|
+
ccToUser?: string;
|
|
679
|
+
/** 部门代码。支持多选 */
|
|
680
|
+
department?: string[];
|
|
681
|
+
/** 排除子流程 */
|
|
682
|
+
excludeSubProcess?: boolean;
|
|
683
|
+
/** 按当前用户管理部门查询 */
|
|
684
|
+
filterByAdminDepartment?: boolean;
|
|
685
|
+
/** ID */
|
|
686
|
+
id?: string;
|
|
687
|
+
/** 包含子部门 */
|
|
688
|
+
includeSubDepartment?: boolean;
|
|
689
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
690
|
+
involvedUser?: string[];
|
|
691
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
692
|
+
nameLike?: string;
|
|
693
|
+
orderBy?: string[];
|
|
694
|
+
/** @format int32 */
|
|
695
|
+
pageIndex?: number;
|
|
696
|
+
/** @format int32 */
|
|
697
|
+
pageSize?: number;
|
|
698
|
+
/** 父流程编号 */
|
|
699
|
+
parentId?: string;
|
|
700
|
+
/** 流程模版ID */
|
|
701
|
+
processDefinitionId?: string;
|
|
702
|
+
/** 流程模版KEY。支持多选 */
|
|
703
|
+
processDefinitionKey?: string[];
|
|
704
|
+
/** 流程模版ID */
|
|
705
|
+
processInstanceId?: string;
|
|
706
|
+
/**
|
|
707
|
+
* 流程启动时间起始
|
|
708
|
+
* @format int64
|
|
709
|
+
*/
|
|
710
|
+
startTimeBegin?: number;
|
|
711
|
+
/**
|
|
712
|
+
* 流程启动时间截止
|
|
713
|
+
* @format int64
|
|
714
|
+
*/
|
|
715
|
+
startTimeEnd?: number;
|
|
716
|
+
/** 流程状态。支持多选 */
|
|
717
|
+
status?: string[];
|
|
718
|
+
/** 内部任务审批人 */
|
|
719
|
+
taskAssignee?: string;
|
|
720
|
+
/** 内部任务候选人 */
|
|
721
|
+
taskCandidateUser?: string;
|
|
722
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
723
|
+
taskDefinitionKey?: string[];
|
|
724
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
725
|
+
taskDefinitionKeyNotIn?: string[];
|
|
726
|
+
/** 内部任务状态 */
|
|
727
|
+
taskStatus?: string[];
|
|
728
|
+
/** UID */
|
|
729
|
+
uid?: string;
|
|
730
|
+
/** 流程发起人。支持多选 */
|
|
731
|
+
user?: string[];
|
|
732
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
733
|
+
variablesMatchCondition?: "And" | "Or";
|
|
734
|
+
/** 返回结果包含抄送人列表 */
|
|
735
|
+
withCcTo?: boolean;
|
|
736
|
+
/** 返回结果包含表单结构 */
|
|
737
|
+
withForm?: boolean;
|
|
738
|
+
/** 返回结果包含表单数据 */
|
|
739
|
+
withFormData?: boolean;
|
|
740
|
+
/** 返回结果包含任务的表单结构 */
|
|
741
|
+
withTaskForm?: boolean;
|
|
742
|
+
/** 返回结果包含任务的表单数据 */
|
|
743
|
+
withTaskFormData?: boolean;
|
|
744
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
745
|
+
withTaskReads?: boolean;
|
|
746
|
+
/** 返回结果包含任务列表 */
|
|
747
|
+
withTasks?: boolean;
|
|
748
|
+
}
|
|
749
|
+
export declare class CandidateForMeParams {
|
|
750
|
+
/** 业务ID。等同于UID */
|
|
751
|
+
businessKey?: string;
|
|
752
|
+
/** 流程撤销人。支持多选 */
|
|
753
|
+
cancelUser?: string[];
|
|
754
|
+
/** 抄送人。不支持多选 */
|
|
755
|
+
ccToUser?: string;
|
|
756
|
+
/** 部门代码。支持多选 */
|
|
757
|
+
department?: string[];
|
|
758
|
+
/** 排除子流程 */
|
|
759
|
+
excludeSubProcess?: boolean;
|
|
760
|
+
/** 按当前用户管理部门查询 */
|
|
761
|
+
filterByAdminDepartment?: boolean;
|
|
762
|
+
/** ID */
|
|
763
|
+
id?: string;
|
|
764
|
+
/** 包含子部门 */
|
|
765
|
+
includeSubDepartment?: boolean;
|
|
766
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
767
|
+
involvedUser?: string[];
|
|
768
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
769
|
+
nameLike?: string;
|
|
770
|
+
orderBy?: string[];
|
|
771
|
+
/** @format int32 */
|
|
772
|
+
pageIndex?: number;
|
|
773
|
+
/** @format int32 */
|
|
774
|
+
pageSize?: number;
|
|
775
|
+
/** 父流程编号 */
|
|
776
|
+
parentId?: string;
|
|
777
|
+
/** 流程模版ID */
|
|
778
|
+
processDefinitionId?: string;
|
|
779
|
+
/** 流程模版KEY。支持多选 */
|
|
780
|
+
processDefinitionKey?: string[];
|
|
781
|
+
/** 流程模版ID */
|
|
782
|
+
processInstanceId?: string;
|
|
783
|
+
/**
|
|
784
|
+
* 流程启动时间起始
|
|
785
|
+
* @format int64
|
|
786
|
+
*/
|
|
787
|
+
startTimeBegin?: number;
|
|
788
|
+
/**
|
|
789
|
+
* 流程启动时间截止
|
|
790
|
+
* @format int64
|
|
791
|
+
*/
|
|
792
|
+
startTimeEnd?: number;
|
|
793
|
+
/** 流程状态。支持多选 */
|
|
794
|
+
status?: string[];
|
|
795
|
+
/** 内部任务审批人 */
|
|
796
|
+
taskAssignee?: string;
|
|
797
|
+
/** 内部任务候选人 */
|
|
798
|
+
taskCandidateUser?: string;
|
|
799
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
800
|
+
taskDefinitionKey?: string[];
|
|
801
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
802
|
+
taskDefinitionKeyNotIn?: string[];
|
|
803
|
+
/** 内部任务状态 */
|
|
804
|
+
taskStatus?: string[];
|
|
805
|
+
/** UID */
|
|
806
|
+
uid?: string;
|
|
807
|
+
/** 流程发起人。支持多选 */
|
|
808
|
+
user?: string[];
|
|
809
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
810
|
+
variablesMatchCondition?: "And" | "Or";
|
|
811
|
+
/** 返回结果包含抄送人列表 */
|
|
812
|
+
withCcTo?: boolean;
|
|
813
|
+
/** 返回结果包含表单结构 */
|
|
814
|
+
withForm?: boolean;
|
|
815
|
+
/** 返回结果包含表单数据 */
|
|
816
|
+
withFormData?: boolean;
|
|
817
|
+
/** 返回结果包含任务的表单结构 */
|
|
818
|
+
withTaskForm?: boolean;
|
|
819
|
+
/** 返回结果包含任务的表单数据 */
|
|
820
|
+
withTaskFormData?: boolean;
|
|
821
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
822
|
+
withTaskReads?: boolean;
|
|
823
|
+
/** 返回结果包含任务列表 */
|
|
824
|
+
withTasks?: boolean;
|
|
825
|
+
}
|
|
826
|
+
export declare class CandidateForMeCountParams {
|
|
827
|
+
/** 业务ID。等同于UID */
|
|
828
|
+
businessKey?: string;
|
|
829
|
+
/** 流程撤销人。支持多选 */
|
|
830
|
+
cancelUser?: string[];
|
|
831
|
+
/** 抄送人。不支持多选 */
|
|
832
|
+
ccToUser?: string;
|
|
833
|
+
/** 部门代码。支持多选 */
|
|
834
|
+
department?: string[];
|
|
835
|
+
/** 排除子流程 */
|
|
836
|
+
excludeSubProcess?: boolean;
|
|
837
|
+
/** 按当前用户管理部门查询 */
|
|
838
|
+
filterByAdminDepartment?: boolean;
|
|
839
|
+
/** ID */
|
|
840
|
+
id?: string;
|
|
841
|
+
/** 包含子部门 */
|
|
842
|
+
includeSubDepartment?: boolean;
|
|
843
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
844
|
+
involvedUser?: string[];
|
|
845
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
846
|
+
nameLike?: string;
|
|
847
|
+
orderBy?: string[];
|
|
848
|
+
/** @format int32 */
|
|
849
|
+
pageIndex?: number;
|
|
850
|
+
/** @format int32 */
|
|
851
|
+
pageSize?: number;
|
|
852
|
+
/** 父流程编号 */
|
|
853
|
+
parentId?: string;
|
|
854
|
+
/** 流程模版ID */
|
|
855
|
+
processDefinitionId?: string;
|
|
856
|
+
/** 流程模版KEY。支持多选 */
|
|
857
|
+
processDefinitionKey?: string[];
|
|
858
|
+
/** 流程模版ID */
|
|
859
|
+
processInstanceId?: string;
|
|
860
|
+
/**
|
|
861
|
+
* 流程启动时间起始
|
|
862
|
+
* @format int64
|
|
863
|
+
*/
|
|
864
|
+
startTimeBegin?: number;
|
|
865
|
+
/**
|
|
866
|
+
* 流程启动时间截止
|
|
867
|
+
* @format int64
|
|
868
|
+
*/
|
|
869
|
+
startTimeEnd?: number;
|
|
870
|
+
/** 流程状态。支持多选 */
|
|
871
|
+
status?: string[];
|
|
872
|
+
/** 内部任务审批人 */
|
|
873
|
+
taskAssignee?: string;
|
|
874
|
+
/** 内部任务候选人 */
|
|
875
|
+
taskCandidateUser?: string;
|
|
876
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
877
|
+
taskDefinitionKey?: string[];
|
|
878
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
879
|
+
taskDefinitionKeyNotIn?: string[];
|
|
880
|
+
/** 内部任务状态 */
|
|
881
|
+
taskStatus?: string[];
|
|
882
|
+
/** UID */
|
|
883
|
+
uid?: string;
|
|
884
|
+
/** 流程发起人。支持多选 */
|
|
885
|
+
user?: string[];
|
|
886
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
887
|
+
variablesMatchCondition?: "And" | "Or";
|
|
888
|
+
/** 返回结果包含抄送人列表 */
|
|
889
|
+
withCcTo?: boolean;
|
|
890
|
+
/** 返回结果包含表单结构 */
|
|
891
|
+
withForm?: boolean;
|
|
892
|
+
/** 返回结果包含表单数据 */
|
|
893
|
+
withFormData?: boolean;
|
|
894
|
+
/** 返回结果包含任务的表单结构 */
|
|
895
|
+
withTaskForm?: boolean;
|
|
896
|
+
/** 返回结果包含任务的表单数据 */
|
|
897
|
+
withTaskFormData?: boolean;
|
|
898
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
899
|
+
withTaskReads?: boolean;
|
|
900
|
+
/** 返回结果包含任务列表 */
|
|
901
|
+
withTasks?: boolean;
|
|
902
|
+
}
|
|
903
|
+
export declare class CcToMeParams {
|
|
904
|
+
/** 业务ID。等同于UID */
|
|
905
|
+
businessKey?: string;
|
|
906
|
+
/** 流程撤销人。支持多选 */
|
|
907
|
+
cancelUser?: string[];
|
|
908
|
+
/** 抄送人。不支持多选 */
|
|
909
|
+
ccToUser?: string;
|
|
910
|
+
/** 部门代码。支持多选 */
|
|
911
|
+
department?: string[];
|
|
912
|
+
/** 排除子流程 */
|
|
913
|
+
excludeSubProcess?: boolean;
|
|
914
|
+
/** 按当前用户管理部门查询 */
|
|
915
|
+
filterByAdminDepartment?: boolean;
|
|
916
|
+
/** ID */
|
|
917
|
+
id?: string;
|
|
918
|
+
/** 包含子部门 */
|
|
919
|
+
includeSubDepartment?: boolean;
|
|
920
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
921
|
+
involvedUser?: string[];
|
|
922
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
923
|
+
nameLike?: string;
|
|
924
|
+
orderBy?: string[];
|
|
925
|
+
/** @format int32 */
|
|
926
|
+
pageIndex?: number;
|
|
927
|
+
/** @format int32 */
|
|
928
|
+
pageSize?: number;
|
|
929
|
+
/** 父流程编号 */
|
|
930
|
+
parentId?: string;
|
|
931
|
+
/** 流程模版ID */
|
|
932
|
+
processDefinitionId?: string;
|
|
933
|
+
/** 流程模版KEY。支持多选 */
|
|
934
|
+
processDefinitionKey?: string[];
|
|
935
|
+
/** 流程模版ID */
|
|
936
|
+
processInstanceId?: string;
|
|
937
|
+
/**
|
|
938
|
+
* 流程启动时间起始
|
|
939
|
+
* @format int64
|
|
940
|
+
*/
|
|
941
|
+
startTimeBegin?: number;
|
|
942
|
+
/**
|
|
943
|
+
* 流程启动时间截止
|
|
944
|
+
* @format int64
|
|
945
|
+
*/
|
|
946
|
+
startTimeEnd?: number;
|
|
947
|
+
/** 流程状态。支持多选 */
|
|
948
|
+
status?: string[];
|
|
949
|
+
/** 内部任务审批人 */
|
|
950
|
+
taskAssignee?: string;
|
|
951
|
+
/** 内部任务候选人 */
|
|
952
|
+
taskCandidateUser?: string;
|
|
953
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
954
|
+
taskDefinitionKey?: string[];
|
|
955
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
956
|
+
taskDefinitionKeyNotIn?: string[];
|
|
957
|
+
/** 内部任务状态 */
|
|
958
|
+
taskStatus?: string[];
|
|
959
|
+
/** UID */
|
|
960
|
+
uid?: string;
|
|
961
|
+
/** 流程发起人。支持多选 */
|
|
962
|
+
user?: string[];
|
|
963
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
964
|
+
variablesMatchCondition?: "And" | "Or";
|
|
965
|
+
/** 返回结果包含抄送人列表 */
|
|
966
|
+
withCcTo?: boolean;
|
|
967
|
+
/** 返回结果包含表单结构 */
|
|
968
|
+
withForm?: boolean;
|
|
969
|
+
/** 返回结果包含表单数据 */
|
|
970
|
+
withFormData?: boolean;
|
|
971
|
+
/** 返回结果包含任务的表单结构 */
|
|
972
|
+
withTaskForm?: boolean;
|
|
973
|
+
/** 返回结果包含任务的表单数据 */
|
|
974
|
+
withTaskFormData?: boolean;
|
|
975
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
976
|
+
withTaskReads?: boolean;
|
|
977
|
+
/** 返回结果包含任务列表 */
|
|
978
|
+
withTasks?: boolean;
|
|
979
|
+
}
|
|
980
|
+
export declare class CcToMeCountParams {
|
|
981
|
+
/** 业务ID。等同于UID */
|
|
982
|
+
businessKey?: string;
|
|
983
|
+
/** 流程撤销人。支持多选 */
|
|
984
|
+
cancelUser?: string[];
|
|
985
|
+
/** 抄送人。不支持多选 */
|
|
986
|
+
ccToUser?: string;
|
|
987
|
+
/** 部门代码。支持多选 */
|
|
988
|
+
department?: string[];
|
|
989
|
+
/** 排除子流程 */
|
|
990
|
+
excludeSubProcess?: boolean;
|
|
991
|
+
/** 按当前用户管理部门查询 */
|
|
992
|
+
filterByAdminDepartment?: boolean;
|
|
993
|
+
/** ID */
|
|
994
|
+
id?: string;
|
|
995
|
+
/** 包含子部门 */
|
|
996
|
+
includeSubDepartment?: boolean;
|
|
997
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
998
|
+
involvedUser?: string[];
|
|
999
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1000
|
+
nameLike?: string;
|
|
1001
|
+
orderBy?: string[];
|
|
1002
|
+
/** @format int32 */
|
|
1003
|
+
pageIndex?: number;
|
|
1004
|
+
/** @format int32 */
|
|
1005
|
+
pageSize?: number;
|
|
1006
|
+
/** 父流程编号 */
|
|
1007
|
+
parentId?: string;
|
|
1008
|
+
/** 流程模版ID */
|
|
1009
|
+
processDefinitionId?: string;
|
|
1010
|
+
/** 流程模版KEY。支持多选 */
|
|
1011
|
+
processDefinitionKey?: string[];
|
|
1012
|
+
/** 流程模版ID */
|
|
1013
|
+
processInstanceId?: string;
|
|
1014
|
+
/**
|
|
1015
|
+
* 流程启动时间起始
|
|
1016
|
+
* @format int64
|
|
1017
|
+
*/
|
|
1018
|
+
startTimeBegin?: number;
|
|
1019
|
+
/**
|
|
1020
|
+
* 流程启动时间截止
|
|
1021
|
+
* @format int64
|
|
1022
|
+
*/
|
|
1023
|
+
startTimeEnd?: number;
|
|
1024
|
+
/** 流程状态。支持多选 */
|
|
1025
|
+
status?: string[];
|
|
1026
|
+
/** 内部任务审批人 */
|
|
1027
|
+
taskAssignee?: string;
|
|
1028
|
+
/** 内部任务候选人 */
|
|
1029
|
+
taskCandidateUser?: string;
|
|
1030
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1031
|
+
taskDefinitionKey?: string[];
|
|
1032
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1033
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1034
|
+
/** 内部任务状态 */
|
|
1035
|
+
taskStatus?: string[];
|
|
1036
|
+
/** UID */
|
|
1037
|
+
uid?: string;
|
|
1038
|
+
/** 流程发起人。支持多选 */
|
|
1039
|
+
user?: string[];
|
|
1040
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1041
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1042
|
+
/** 返回结果包含抄送人列表 */
|
|
1043
|
+
withCcTo?: boolean;
|
|
1044
|
+
/** 返回结果包含表单结构 */
|
|
1045
|
+
withForm?: boolean;
|
|
1046
|
+
/** 返回结果包含表单数据 */
|
|
1047
|
+
withFormData?: boolean;
|
|
1048
|
+
/** 返回结果包含任务的表单结构 */
|
|
1049
|
+
withTaskForm?: boolean;
|
|
1050
|
+
/** 返回结果包含任务的表单数据 */
|
|
1051
|
+
withTaskFormData?: boolean;
|
|
1052
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1053
|
+
withTaskReads?: boolean;
|
|
1054
|
+
/** 返回结果包含任务列表 */
|
|
1055
|
+
withTasks?: boolean;
|
|
1056
|
+
}
|
|
1057
|
+
export declare class CompletedByMeParams {
|
|
1058
|
+
/** 业务ID。等同于UID */
|
|
1059
|
+
businessKey?: string;
|
|
1060
|
+
/** 流程撤销人。支持多选 */
|
|
1061
|
+
cancelUser?: string[];
|
|
1062
|
+
/** 抄送人。不支持多选 */
|
|
1063
|
+
ccToUser?: string;
|
|
1064
|
+
/** 部门代码。支持多选 */
|
|
1065
|
+
department?: string[];
|
|
1066
|
+
/** 排除子流程 */
|
|
1067
|
+
excludeSubProcess?: boolean;
|
|
1068
|
+
/** 按当前用户管理部门查询 */
|
|
1069
|
+
filterByAdminDepartment?: boolean;
|
|
1070
|
+
/** ID */
|
|
1071
|
+
id?: string;
|
|
1072
|
+
/** 包含子部门 */
|
|
1073
|
+
includeSubDepartment?: boolean;
|
|
1074
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1075
|
+
involvedUser?: string[];
|
|
1076
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1077
|
+
nameLike?: string;
|
|
1078
|
+
orderBy?: string[];
|
|
1079
|
+
/** @format int32 */
|
|
1080
|
+
pageIndex?: number;
|
|
1081
|
+
/** @format int32 */
|
|
1082
|
+
pageSize?: number;
|
|
1083
|
+
/** 父流程编号 */
|
|
1084
|
+
parentId?: string;
|
|
1085
|
+
/** 流程模版ID */
|
|
1086
|
+
processDefinitionId?: string;
|
|
1087
|
+
/** 流程模版KEY。支持多选 */
|
|
1088
|
+
processDefinitionKey?: string[];
|
|
1089
|
+
/** 流程模版ID */
|
|
1090
|
+
processInstanceId?: string;
|
|
1091
|
+
/**
|
|
1092
|
+
* 流程启动时间起始
|
|
1093
|
+
* @format int64
|
|
1094
|
+
*/
|
|
1095
|
+
startTimeBegin?: number;
|
|
1096
|
+
/**
|
|
1097
|
+
* 流程启动时间截止
|
|
1098
|
+
* @format int64
|
|
1099
|
+
*/
|
|
1100
|
+
startTimeEnd?: number;
|
|
1101
|
+
/** 流程状态。支持多选 */
|
|
1102
|
+
status?: string[];
|
|
1103
|
+
/** 内部任务审批人 */
|
|
1104
|
+
taskAssignee?: string;
|
|
1105
|
+
/** 内部任务候选人 */
|
|
1106
|
+
taskCandidateUser?: string;
|
|
1107
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1108
|
+
taskDefinitionKey?: string[];
|
|
1109
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1110
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1111
|
+
/** 内部任务状态 */
|
|
1112
|
+
taskStatus?: string[];
|
|
1113
|
+
/** UID */
|
|
1114
|
+
uid?: string;
|
|
1115
|
+
/** 流程发起人。支持多选 */
|
|
1116
|
+
user?: string[];
|
|
1117
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1118
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1119
|
+
/** 返回结果包含抄送人列表 */
|
|
1120
|
+
withCcTo?: boolean;
|
|
1121
|
+
/** 返回结果包含表单结构 */
|
|
1122
|
+
withForm?: boolean;
|
|
1123
|
+
/** 返回结果包含表单数据 */
|
|
1124
|
+
withFormData?: boolean;
|
|
1125
|
+
/** 返回结果包含任务的表单结构 */
|
|
1126
|
+
withTaskForm?: boolean;
|
|
1127
|
+
/** 返回结果包含任务的表单数据 */
|
|
1128
|
+
withTaskFormData?: boolean;
|
|
1129
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1130
|
+
withTaskReads?: boolean;
|
|
1131
|
+
/** 返回结果包含任务列表 */
|
|
1132
|
+
withTasks?: boolean;
|
|
1133
|
+
}
|
|
1134
|
+
export declare class CompletedByMeCountParams {
|
|
1135
|
+
/** 业务ID。等同于UID */
|
|
1136
|
+
businessKey?: string;
|
|
1137
|
+
/** 流程撤销人。支持多选 */
|
|
1138
|
+
cancelUser?: string[];
|
|
1139
|
+
/** 抄送人。不支持多选 */
|
|
1140
|
+
ccToUser?: string;
|
|
1141
|
+
/** 部门代码。支持多选 */
|
|
1142
|
+
department?: string[];
|
|
1143
|
+
/** 排除子流程 */
|
|
1144
|
+
excludeSubProcess?: boolean;
|
|
1145
|
+
/** 按当前用户管理部门查询 */
|
|
1146
|
+
filterByAdminDepartment?: boolean;
|
|
1147
|
+
/** ID */
|
|
1148
|
+
id?: string;
|
|
1149
|
+
/** 包含子部门 */
|
|
1150
|
+
includeSubDepartment?: boolean;
|
|
1151
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1152
|
+
involvedUser?: string[];
|
|
1153
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1154
|
+
nameLike?: string;
|
|
1155
|
+
orderBy?: string[];
|
|
1156
|
+
/** @format int32 */
|
|
1157
|
+
pageIndex?: number;
|
|
1158
|
+
/** @format int32 */
|
|
1159
|
+
pageSize?: number;
|
|
1160
|
+
/** 父流程编号 */
|
|
1161
|
+
parentId?: string;
|
|
1162
|
+
/** 流程模版ID */
|
|
1163
|
+
processDefinitionId?: string;
|
|
1164
|
+
/** 流程模版KEY。支持多选 */
|
|
1165
|
+
processDefinitionKey?: string[];
|
|
1166
|
+
/** 流程模版ID */
|
|
1167
|
+
processInstanceId?: string;
|
|
1168
|
+
/**
|
|
1169
|
+
* 流程启动时间起始
|
|
1170
|
+
* @format int64
|
|
1171
|
+
*/
|
|
1172
|
+
startTimeBegin?: number;
|
|
1173
|
+
/**
|
|
1174
|
+
* 流程启动时间截止
|
|
1175
|
+
* @format int64
|
|
1176
|
+
*/
|
|
1177
|
+
startTimeEnd?: number;
|
|
1178
|
+
/** 流程状态。支持多选 */
|
|
1179
|
+
status?: string[];
|
|
1180
|
+
/** 内部任务审批人 */
|
|
1181
|
+
taskAssignee?: string;
|
|
1182
|
+
/** 内部任务候选人 */
|
|
1183
|
+
taskCandidateUser?: string;
|
|
1184
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1185
|
+
taskDefinitionKey?: string[];
|
|
1186
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1187
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1188
|
+
/** 内部任务状态 */
|
|
1189
|
+
taskStatus?: string[];
|
|
1190
|
+
/** UID */
|
|
1191
|
+
uid?: string;
|
|
1192
|
+
/** 流程发起人。支持多选 */
|
|
1193
|
+
user?: string[];
|
|
1194
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1195
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1196
|
+
/** 返回结果包含抄送人列表 */
|
|
1197
|
+
withCcTo?: boolean;
|
|
1198
|
+
/** 返回结果包含表单结构 */
|
|
1199
|
+
withForm?: boolean;
|
|
1200
|
+
/** 返回结果包含表单数据 */
|
|
1201
|
+
withFormData?: boolean;
|
|
1202
|
+
/** 返回结果包含任务的表单结构 */
|
|
1203
|
+
withTaskForm?: boolean;
|
|
1204
|
+
/** 返回结果包含任务的表单数据 */
|
|
1205
|
+
withTaskFormData?: boolean;
|
|
1206
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1207
|
+
withTaskReads?: boolean;
|
|
1208
|
+
/** 返回结果包含任务列表 */
|
|
1209
|
+
withTasks?: boolean;
|
|
1210
|
+
}
|
|
1211
|
+
export declare class CountParams {
|
|
1212
|
+
/** 业务ID。等同于UID */
|
|
1213
|
+
businessKey?: string;
|
|
1214
|
+
/** 流程撤销人。支持多选 */
|
|
1215
|
+
cancelUser?: string[];
|
|
1216
|
+
/** 抄送人。不支持多选 */
|
|
1217
|
+
ccToUser?: string;
|
|
1218
|
+
/** 部门代码。支持多选 */
|
|
1219
|
+
department?: string[];
|
|
1220
|
+
/** 排除子流程 */
|
|
1221
|
+
excludeSubProcess?: boolean;
|
|
1222
|
+
/** 按当前用户管理部门查询 */
|
|
1223
|
+
filterByAdminDepartment?: boolean;
|
|
1224
|
+
/** ID */
|
|
1225
|
+
id?: string;
|
|
1226
|
+
/** 包含子部门 */
|
|
1227
|
+
includeSubDepartment?: boolean;
|
|
1228
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1229
|
+
involvedUser?: string[];
|
|
1230
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1231
|
+
nameLike?: string;
|
|
1232
|
+
orderBy?: string[];
|
|
1233
|
+
/** @format int32 */
|
|
1234
|
+
pageIndex?: number;
|
|
1235
|
+
/** @format int32 */
|
|
1236
|
+
pageSize?: number;
|
|
1237
|
+
/** 父流程编号 */
|
|
1238
|
+
parentId?: string;
|
|
1239
|
+
/** 流程模版ID */
|
|
1240
|
+
processDefinitionId?: string;
|
|
1241
|
+
/** 流程模版KEY。支持多选 */
|
|
1242
|
+
processDefinitionKey?: string[];
|
|
1243
|
+
/** 流程模版ID */
|
|
1244
|
+
processInstanceId?: string;
|
|
1245
|
+
/**
|
|
1246
|
+
* 流程启动时间起始
|
|
1247
|
+
* @format int64
|
|
1248
|
+
*/
|
|
1249
|
+
startTimeBegin?: number;
|
|
1250
|
+
/**
|
|
1251
|
+
* 流程启动时间截止
|
|
1252
|
+
* @format int64
|
|
1253
|
+
*/
|
|
1254
|
+
startTimeEnd?: number;
|
|
1255
|
+
/** 流程状态。支持多选 */
|
|
1256
|
+
status?: string[];
|
|
1257
|
+
/** 内部任务审批人 */
|
|
1258
|
+
taskAssignee?: string;
|
|
1259
|
+
/** 内部任务候选人 */
|
|
1260
|
+
taskCandidateUser?: string;
|
|
1261
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1262
|
+
taskDefinitionKey?: string[];
|
|
1263
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1264
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1265
|
+
/** 内部任务状态 */
|
|
1266
|
+
taskStatus?: string[];
|
|
1267
|
+
/** UID */
|
|
1268
|
+
uid?: string;
|
|
1269
|
+
/** 流程发起人。支持多选 */
|
|
1270
|
+
user?: string[];
|
|
1271
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1272
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1273
|
+
/** 返回结果包含抄送人列表 */
|
|
1274
|
+
withCcTo?: boolean;
|
|
1275
|
+
/** 返回结果包含表单结构 */
|
|
1276
|
+
withForm?: boolean;
|
|
1277
|
+
/** 返回结果包含表单数据 */
|
|
1278
|
+
withFormData?: boolean;
|
|
1279
|
+
/** 返回结果包含任务的表单结构 */
|
|
1280
|
+
withTaskForm?: boolean;
|
|
1281
|
+
/** 返回结果包含任务的表单数据 */
|
|
1282
|
+
withTaskFormData?: boolean;
|
|
1283
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1284
|
+
withTaskReads?: boolean;
|
|
1285
|
+
/** 返回结果包含任务列表 */
|
|
1286
|
+
withTasks?: boolean;
|
|
1287
|
+
}
|
|
1288
|
+
export declare class DetailByUidByUidParams {
|
|
1289
|
+
/** 返回结果包含表单结构 */
|
|
1290
|
+
withForm?: boolean;
|
|
1291
|
+
/** 返回结果包含表单数据 */
|
|
1292
|
+
withFormData?: boolean;
|
|
1293
|
+
/** 返回结果包含任务列表 */
|
|
1294
|
+
withTasks?: boolean;
|
|
1295
|
+
/** 返回结果包含抄送人列表 */
|
|
1296
|
+
withCcTo?: boolean;
|
|
1297
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1298
|
+
withTaskReads?: boolean;
|
|
1299
|
+
/** uid */
|
|
1300
|
+
uid: string;
|
|
1301
|
+
}
|
|
1302
|
+
export declare class DetailByIdParams {
|
|
1303
|
+
/** 返回结果包含表单结构 */
|
|
1304
|
+
withForm?: boolean;
|
|
1305
|
+
/** 返回结果包含表单数据 */
|
|
1306
|
+
withFormData?: boolean;
|
|
1307
|
+
/** 返回结果包含任务列表 */
|
|
1308
|
+
withTasks?: boolean;
|
|
1309
|
+
/** 返回结果包含抄送人列表 */
|
|
1310
|
+
withCcTo?: boolean;
|
|
1311
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1312
|
+
withTaskReads?: boolean;
|
|
1313
|
+
/** id */
|
|
1314
|
+
id: string;
|
|
1315
|
+
}
|
|
1316
|
+
export declare class InvolvedByMeParams {
|
|
1317
|
+
/** 业务ID。等同于UID */
|
|
1318
|
+
businessKey?: string;
|
|
1319
|
+
/** 流程撤销人。支持多选 */
|
|
1320
|
+
cancelUser?: string[];
|
|
1321
|
+
/** 抄送人。不支持多选 */
|
|
1322
|
+
ccToUser?: string;
|
|
1323
|
+
/** 部门代码。支持多选 */
|
|
1324
|
+
department?: string[];
|
|
1325
|
+
/** 排除子流程 */
|
|
1326
|
+
excludeSubProcess?: boolean;
|
|
1327
|
+
/** 按当前用户管理部门查询 */
|
|
1328
|
+
filterByAdminDepartment?: boolean;
|
|
1329
|
+
/** ID */
|
|
1330
|
+
id?: string;
|
|
1331
|
+
/** 包含子部门 */
|
|
1332
|
+
includeSubDepartment?: boolean;
|
|
1333
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1334
|
+
involvedUser?: string[];
|
|
1335
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1336
|
+
nameLike?: string;
|
|
1337
|
+
orderBy?: string[];
|
|
1338
|
+
/** @format int32 */
|
|
1339
|
+
pageIndex?: number;
|
|
1340
|
+
/** @format int32 */
|
|
1341
|
+
pageSize?: number;
|
|
1342
|
+
/** 父流程编号 */
|
|
1343
|
+
parentId?: string;
|
|
1344
|
+
/** 流程模版ID */
|
|
1345
|
+
processDefinitionId?: string;
|
|
1346
|
+
/** 流程模版KEY。支持多选 */
|
|
1347
|
+
processDefinitionKey?: string[];
|
|
1348
|
+
/** 流程模版ID */
|
|
1349
|
+
processInstanceId?: string;
|
|
1350
|
+
/**
|
|
1351
|
+
* 流程启动时间起始
|
|
1352
|
+
* @format int64
|
|
1353
|
+
*/
|
|
1354
|
+
startTimeBegin?: number;
|
|
1355
|
+
/**
|
|
1356
|
+
* 流程启动时间截止
|
|
1357
|
+
* @format int64
|
|
1358
|
+
*/
|
|
1359
|
+
startTimeEnd?: number;
|
|
1360
|
+
/** 流程状态。支持多选 */
|
|
1361
|
+
status?: string[];
|
|
1362
|
+
/** 内部任务审批人 */
|
|
1363
|
+
taskAssignee?: string;
|
|
1364
|
+
/** 内部任务候选人 */
|
|
1365
|
+
taskCandidateUser?: string;
|
|
1366
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1367
|
+
taskDefinitionKey?: string[];
|
|
1368
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1369
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1370
|
+
/** 内部任务状态 */
|
|
1371
|
+
taskStatus?: string[];
|
|
1372
|
+
/** UID */
|
|
1373
|
+
uid?: string;
|
|
1374
|
+
/** 流程发起人。支持多选 */
|
|
1375
|
+
user?: string[];
|
|
1376
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1377
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1378
|
+
/** 返回结果包含抄送人列表 */
|
|
1379
|
+
withCcTo?: boolean;
|
|
1380
|
+
/** 返回结果包含表单结构 */
|
|
1381
|
+
withForm?: boolean;
|
|
1382
|
+
/** 返回结果包含表单数据 */
|
|
1383
|
+
withFormData?: boolean;
|
|
1384
|
+
/** 返回结果包含任务的表单结构 */
|
|
1385
|
+
withTaskForm?: boolean;
|
|
1386
|
+
/** 返回结果包含任务的表单数据 */
|
|
1387
|
+
withTaskFormData?: boolean;
|
|
1388
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1389
|
+
withTaskReads?: boolean;
|
|
1390
|
+
/** 返回结果包含任务列表 */
|
|
1391
|
+
withTasks?: boolean;
|
|
1392
|
+
}
|
|
1393
|
+
export declare class InvolvedByMeCountParams {
|
|
1394
|
+
/** 业务ID。等同于UID */
|
|
1395
|
+
businessKey?: string;
|
|
1396
|
+
/** 流程撤销人。支持多选 */
|
|
1397
|
+
cancelUser?: string[];
|
|
1398
|
+
/** 抄送人。不支持多选 */
|
|
1399
|
+
ccToUser?: string;
|
|
1400
|
+
/** 部门代码。支持多选 */
|
|
1401
|
+
department?: string[];
|
|
1402
|
+
/** 排除子流程 */
|
|
1403
|
+
excludeSubProcess?: boolean;
|
|
1404
|
+
/** 按当前用户管理部门查询 */
|
|
1405
|
+
filterByAdminDepartment?: boolean;
|
|
1406
|
+
/** ID */
|
|
1407
|
+
id?: string;
|
|
1408
|
+
/** 包含子部门 */
|
|
1409
|
+
includeSubDepartment?: boolean;
|
|
1410
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1411
|
+
involvedUser?: string[];
|
|
1412
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1413
|
+
nameLike?: string;
|
|
1414
|
+
orderBy?: string[];
|
|
1415
|
+
/** @format int32 */
|
|
1416
|
+
pageIndex?: number;
|
|
1417
|
+
/** @format int32 */
|
|
1418
|
+
pageSize?: number;
|
|
1419
|
+
/** 父流程编号 */
|
|
1420
|
+
parentId?: string;
|
|
1421
|
+
/** 流程模版ID */
|
|
1422
|
+
processDefinitionId?: string;
|
|
1423
|
+
/** 流程模版KEY。支持多选 */
|
|
1424
|
+
processDefinitionKey?: string[];
|
|
1425
|
+
/** 流程模版ID */
|
|
1426
|
+
processInstanceId?: string;
|
|
1427
|
+
/**
|
|
1428
|
+
* 流程启动时间起始
|
|
1429
|
+
* @format int64
|
|
1430
|
+
*/
|
|
1431
|
+
startTimeBegin?: number;
|
|
1432
|
+
/**
|
|
1433
|
+
* 流程启动时间截止
|
|
1434
|
+
* @format int64
|
|
1435
|
+
*/
|
|
1436
|
+
startTimeEnd?: number;
|
|
1437
|
+
/** 流程状态。支持多选 */
|
|
1438
|
+
status?: string[];
|
|
1439
|
+
/** 内部任务审批人 */
|
|
1440
|
+
taskAssignee?: string;
|
|
1441
|
+
/** 内部任务候选人 */
|
|
1442
|
+
taskCandidateUser?: string;
|
|
1443
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1444
|
+
taskDefinitionKey?: string[];
|
|
1445
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1446
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1447
|
+
/** 内部任务状态 */
|
|
1448
|
+
taskStatus?: string[];
|
|
1449
|
+
/** UID */
|
|
1450
|
+
uid?: string;
|
|
1451
|
+
/** 流程发起人。支持多选 */
|
|
1452
|
+
user?: string[];
|
|
1453
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1454
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1455
|
+
/** 返回结果包含抄送人列表 */
|
|
1456
|
+
withCcTo?: boolean;
|
|
1457
|
+
/** 返回结果包含表单结构 */
|
|
1458
|
+
withForm?: boolean;
|
|
1459
|
+
/** 返回结果包含表单数据 */
|
|
1460
|
+
withFormData?: boolean;
|
|
1461
|
+
/** 返回结果包含任务的表单结构 */
|
|
1462
|
+
withTaskForm?: boolean;
|
|
1463
|
+
/** 返回结果包含任务的表单数据 */
|
|
1464
|
+
withTaskFormData?: boolean;
|
|
1465
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1466
|
+
withTaskReads?: boolean;
|
|
1467
|
+
/** 返回结果包含任务列表 */
|
|
1468
|
+
withTasks?: boolean;
|
|
1469
|
+
}
|
|
1470
|
+
export declare class ListParams {
|
|
1471
|
+
/** 流程ID集合 */
|
|
1472
|
+
ids: string;
|
|
1473
|
+
/** 返回结果包含表单结构 */
|
|
1474
|
+
withForm?: boolean;
|
|
1475
|
+
/** 返回结果包含表单数据 */
|
|
1476
|
+
withFormData?: boolean;
|
|
1477
|
+
/** 返回结果包含任务列表 */
|
|
1478
|
+
withTasks?: boolean;
|
|
1479
|
+
/** 返回结果包含抄送人列表 */
|
|
1480
|
+
withCcTo?: boolean;
|
|
1481
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1482
|
+
withTaskReads?: boolean;
|
|
1483
|
+
}
|
|
1484
|
+
export declare class SubmitByMeParams {
|
|
1485
|
+
/** 业务ID。等同于UID */
|
|
1486
|
+
businessKey?: string;
|
|
1487
|
+
/** 流程撤销人。支持多选 */
|
|
1488
|
+
cancelUser?: string[];
|
|
1489
|
+
/** 抄送人。不支持多选 */
|
|
1490
|
+
ccToUser?: string;
|
|
1491
|
+
/** 部门代码。支持多选 */
|
|
1492
|
+
department?: string[];
|
|
1493
|
+
/** 排除子流程 */
|
|
1494
|
+
excludeSubProcess?: boolean;
|
|
1495
|
+
/** 按当前用户管理部门查询 */
|
|
1496
|
+
filterByAdminDepartment?: boolean;
|
|
1497
|
+
/** ID */
|
|
1498
|
+
id?: string;
|
|
1499
|
+
/** 包含子部门 */
|
|
1500
|
+
includeSubDepartment?: boolean;
|
|
1501
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1502
|
+
involvedUser?: string[];
|
|
1503
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1504
|
+
nameLike?: string;
|
|
1505
|
+
orderBy?: string[];
|
|
1506
|
+
/** @format int32 */
|
|
1507
|
+
pageIndex?: number;
|
|
1508
|
+
/** @format int32 */
|
|
1509
|
+
pageSize?: number;
|
|
1510
|
+
/** 父流程编号 */
|
|
1511
|
+
parentId?: string;
|
|
1512
|
+
/** 流程模版ID */
|
|
1513
|
+
processDefinitionId?: string;
|
|
1514
|
+
/** 流程模版KEY。支持多选 */
|
|
1515
|
+
processDefinitionKey?: string[];
|
|
1516
|
+
/** 流程模版ID */
|
|
1517
|
+
processInstanceId?: string;
|
|
1518
|
+
/**
|
|
1519
|
+
* 流程启动时间起始
|
|
1520
|
+
* @format int64
|
|
1521
|
+
*/
|
|
1522
|
+
startTimeBegin?: number;
|
|
1523
|
+
/**
|
|
1524
|
+
* 流程启动时间截止
|
|
1525
|
+
* @format int64
|
|
1526
|
+
*/
|
|
1527
|
+
startTimeEnd?: number;
|
|
1528
|
+
/** 流程状态。支持多选 */
|
|
1529
|
+
status?: string[];
|
|
1530
|
+
/** 内部任务审批人 */
|
|
1531
|
+
taskAssignee?: string;
|
|
1532
|
+
/** 内部任务候选人 */
|
|
1533
|
+
taskCandidateUser?: string;
|
|
1534
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1535
|
+
taskDefinitionKey?: string[];
|
|
1536
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1537
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1538
|
+
/** 内部任务状态 */
|
|
1539
|
+
taskStatus?: string[];
|
|
1540
|
+
/** UID */
|
|
1541
|
+
uid?: string;
|
|
1542
|
+
/** 流程发起人。支持多选 */
|
|
1543
|
+
user?: string[];
|
|
1544
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1545
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1546
|
+
/** 返回结果包含抄送人列表 */
|
|
1547
|
+
withCcTo?: boolean;
|
|
1548
|
+
/** 返回结果包含表单结构 */
|
|
1549
|
+
withForm?: boolean;
|
|
1550
|
+
/** 返回结果包含表单数据 */
|
|
1551
|
+
withFormData?: boolean;
|
|
1552
|
+
/** 返回结果包含任务的表单结构 */
|
|
1553
|
+
withTaskForm?: boolean;
|
|
1554
|
+
/** 返回结果包含任务的表单数据 */
|
|
1555
|
+
withTaskFormData?: boolean;
|
|
1556
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1557
|
+
withTaskReads?: boolean;
|
|
1558
|
+
/** 返回结果包含任务列表 */
|
|
1559
|
+
withTasks?: boolean;
|
|
1560
|
+
}
|
|
1561
|
+
export declare class SubmitByMeCountParams {
|
|
1562
|
+
/** 业务ID。等同于UID */
|
|
1563
|
+
businessKey?: string;
|
|
1564
|
+
/** 流程撤销人。支持多选 */
|
|
1565
|
+
cancelUser?: string[];
|
|
1566
|
+
/** 抄送人。不支持多选 */
|
|
1567
|
+
ccToUser?: string;
|
|
1568
|
+
/** 部门代码。支持多选 */
|
|
1569
|
+
department?: string[];
|
|
1570
|
+
/** 排除子流程 */
|
|
1571
|
+
excludeSubProcess?: boolean;
|
|
1572
|
+
/** 按当前用户管理部门查询 */
|
|
1573
|
+
filterByAdminDepartment?: boolean;
|
|
1574
|
+
/** ID */
|
|
1575
|
+
id?: string;
|
|
1576
|
+
/** 包含子部门 */
|
|
1577
|
+
includeSubDepartment?: boolean;
|
|
1578
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1579
|
+
involvedUser?: string[];
|
|
1580
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1581
|
+
nameLike?: string;
|
|
1582
|
+
orderBy?: string[];
|
|
1583
|
+
/** @format int32 */
|
|
1584
|
+
pageIndex?: number;
|
|
1585
|
+
/** @format int32 */
|
|
1586
|
+
pageSize?: number;
|
|
1587
|
+
/** 父流程编号 */
|
|
1588
|
+
parentId?: string;
|
|
1589
|
+
/** 流程模版ID */
|
|
1590
|
+
processDefinitionId?: string;
|
|
1591
|
+
/** 流程模版KEY。支持多选 */
|
|
1592
|
+
processDefinitionKey?: string[];
|
|
1593
|
+
/** 流程模版ID */
|
|
1594
|
+
processInstanceId?: string;
|
|
1595
|
+
/**
|
|
1596
|
+
* 流程启动时间起始
|
|
1597
|
+
* @format int64
|
|
1598
|
+
*/
|
|
1599
|
+
startTimeBegin?: number;
|
|
1600
|
+
/**
|
|
1601
|
+
* 流程启动时间截止
|
|
1602
|
+
* @format int64
|
|
1603
|
+
*/
|
|
1604
|
+
startTimeEnd?: number;
|
|
1605
|
+
/** 流程状态。支持多选 */
|
|
1606
|
+
status?: string[];
|
|
1607
|
+
/** 内部任务审批人 */
|
|
1608
|
+
taskAssignee?: string;
|
|
1609
|
+
/** 内部任务候选人 */
|
|
1610
|
+
taskCandidateUser?: string;
|
|
1611
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1612
|
+
taskDefinitionKey?: string[];
|
|
1613
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1614
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1615
|
+
/** 内部任务状态 */
|
|
1616
|
+
taskStatus?: string[];
|
|
1617
|
+
/** UID */
|
|
1618
|
+
uid?: string;
|
|
1619
|
+
/** 流程发起人。支持多选 */
|
|
1620
|
+
user?: string[];
|
|
1621
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1622
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1623
|
+
/** 返回结果包含抄送人列表 */
|
|
1624
|
+
withCcTo?: boolean;
|
|
1625
|
+
/** 返回结果包含表单结构 */
|
|
1626
|
+
withForm?: boolean;
|
|
1627
|
+
/** 返回结果包含表单数据 */
|
|
1628
|
+
withFormData?: boolean;
|
|
1629
|
+
/** 返回结果包含任务的表单结构 */
|
|
1630
|
+
withTaskForm?: boolean;
|
|
1631
|
+
/** 返回结果包含任务的表单数据 */
|
|
1632
|
+
withTaskFormData?: boolean;
|
|
1633
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1634
|
+
withTaskReads?: boolean;
|
|
1635
|
+
/** 返回结果包含任务列表 */
|
|
1636
|
+
withTasks?: boolean;
|
|
1637
|
+
}
|
|
1638
|
+
export declare class WaitingForMeParams {
|
|
1639
|
+
/** 业务ID。等同于UID */
|
|
1640
|
+
businessKey?: string;
|
|
1641
|
+
/** 流程撤销人。支持多选 */
|
|
1642
|
+
cancelUser?: string[];
|
|
1643
|
+
/** 抄送人。不支持多选 */
|
|
1644
|
+
ccToUser?: string;
|
|
1645
|
+
/** 部门代码。支持多选 */
|
|
1646
|
+
department?: string[];
|
|
1647
|
+
/** 排除子流程 */
|
|
1648
|
+
excludeSubProcess?: boolean;
|
|
1649
|
+
/** 按当前用户管理部门查询 */
|
|
1650
|
+
filterByAdminDepartment?: boolean;
|
|
1651
|
+
/** ID */
|
|
1652
|
+
id?: string;
|
|
1653
|
+
/** 包含子部门 */
|
|
1654
|
+
includeSubDepartment?: boolean;
|
|
1655
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1656
|
+
involvedUser?: string[];
|
|
1657
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1658
|
+
nameLike?: string;
|
|
1659
|
+
orderBy?: string[];
|
|
1660
|
+
/** @format int32 */
|
|
1661
|
+
pageIndex?: number;
|
|
1662
|
+
/** @format int32 */
|
|
1663
|
+
pageSize?: number;
|
|
1664
|
+
/** 父流程编号 */
|
|
1665
|
+
parentId?: string;
|
|
1666
|
+
/** 流程模版ID */
|
|
1667
|
+
processDefinitionId?: string;
|
|
1668
|
+
/** 流程模版KEY。支持多选 */
|
|
1669
|
+
processDefinitionKey?: string[];
|
|
1670
|
+
/** 流程模版ID */
|
|
1671
|
+
processInstanceId?: string;
|
|
1672
|
+
/**
|
|
1673
|
+
* 流程启动时间起始
|
|
1674
|
+
* @format int64
|
|
1675
|
+
*/
|
|
1676
|
+
startTimeBegin?: number;
|
|
1677
|
+
/**
|
|
1678
|
+
* 流程启动时间截止
|
|
1679
|
+
* @format int64
|
|
1680
|
+
*/
|
|
1681
|
+
startTimeEnd?: number;
|
|
1682
|
+
/** 流程状态。支持多选 */
|
|
1683
|
+
status?: string[];
|
|
1684
|
+
/** 内部任务审批人 */
|
|
1685
|
+
taskAssignee?: string;
|
|
1686
|
+
/** 内部任务候选人 */
|
|
1687
|
+
taskCandidateUser?: string;
|
|
1688
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1689
|
+
taskDefinitionKey?: string[];
|
|
1690
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1691
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1692
|
+
/** 内部任务状态 */
|
|
1693
|
+
taskStatus?: string[];
|
|
1694
|
+
/** UID */
|
|
1695
|
+
uid?: string;
|
|
1696
|
+
/** 流程发起人。支持多选 */
|
|
1697
|
+
user?: string[];
|
|
1698
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1699
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1700
|
+
/** 返回结果包含抄送人列表 */
|
|
1701
|
+
withCcTo?: boolean;
|
|
1702
|
+
/** 返回结果包含表单结构 */
|
|
1703
|
+
withForm?: boolean;
|
|
1704
|
+
/** 返回结果包含表单数据 */
|
|
1705
|
+
withFormData?: boolean;
|
|
1706
|
+
/** 返回结果包含任务的表单结构 */
|
|
1707
|
+
withTaskForm?: boolean;
|
|
1708
|
+
/** 返回结果包含任务的表单数据 */
|
|
1709
|
+
withTaskFormData?: boolean;
|
|
1710
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1711
|
+
withTaskReads?: boolean;
|
|
1712
|
+
/** 返回结果包含任务列表 */
|
|
1713
|
+
withTasks?: boolean;
|
|
1714
|
+
}
|
|
1715
|
+
export declare class WaitingForMeCountParams {
|
|
1716
|
+
/** 业务ID。等同于UID */
|
|
1717
|
+
businessKey?: string;
|
|
1718
|
+
/** 流程撤销人。支持多选 */
|
|
1719
|
+
cancelUser?: string[];
|
|
1720
|
+
/** 抄送人。不支持多选 */
|
|
1721
|
+
ccToUser?: string;
|
|
1722
|
+
/** 部门代码。支持多选 */
|
|
1723
|
+
department?: string[];
|
|
1724
|
+
/** 排除子流程 */
|
|
1725
|
+
excludeSubProcess?: boolean;
|
|
1726
|
+
/** 按当前用户管理部门查询 */
|
|
1727
|
+
filterByAdminDepartment?: boolean;
|
|
1728
|
+
/** ID */
|
|
1729
|
+
id?: string;
|
|
1730
|
+
/** 包含子部门 */
|
|
1731
|
+
includeSubDepartment?: boolean;
|
|
1732
|
+
/** 关联人员(审批人或流程发起人)。支持多选 */
|
|
1733
|
+
involvedUser?: string[];
|
|
1734
|
+
/** 流程名称。需要自行添加 % 进行模糊匹配 */
|
|
1735
|
+
nameLike?: string;
|
|
1736
|
+
orderBy?: string[];
|
|
1737
|
+
/** @format int32 */
|
|
1738
|
+
pageIndex?: number;
|
|
1739
|
+
/** @format int32 */
|
|
1740
|
+
pageSize?: number;
|
|
1741
|
+
/** 父流程编号 */
|
|
1742
|
+
parentId?: string;
|
|
1743
|
+
/** 流程模版ID */
|
|
1744
|
+
processDefinitionId?: string;
|
|
1745
|
+
/** 流程模版KEY。支持多选 */
|
|
1746
|
+
processDefinitionKey?: string[];
|
|
1747
|
+
/** 流程模版ID */
|
|
1748
|
+
processInstanceId?: string;
|
|
1749
|
+
/**
|
|
1750
|
+
* 流程启动时间起始
|
|
1751
|
+
* @format int64
|
|
1752
|
+
*/
|
|
1753
|
+
startTimeBegin?: number;
|
|
1754
|
+
/**
|
|
1755
|
+
* 流程启动时间截止
|
|
1756
|
+
* @format int64
|
|
1757
|
+
*/
|
|
1758
|
+
startTimeEnd?: number;
|
|
1759
|
+
/** 流程状态。支持多选 */
|
|
1760
|
+
status?: string[];
|
|
1761
|
+
/** 内部任务审批人 */
|
|
1762
|
+
taskAssignee?: string;
|
|
1763
|
+
/** 内部任务候选人 */
|
|
1764
|
+
taskCandidateUser?: string;
|
|
1765
|
+
/** 内部任务节点KEY匹配。支持多选 */
|
|
1766
|
+
taskDefinitionKey?: string[];
|
|
1767
|
+
/** 内部任务节点KEY排除。支持多选 */
|
|
1768
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1769
|
+
/** 内部任务状态 */
|
|
1770
|
+
taskStatus?: string[];
|
|
1771
|
+
/** UID */
|
|
1772
|
+
uid?: string;
|
|
1773
|
+
/** 流程发起人。支持多选 */
|
|
1774
|
+
user?: string[];
|
|
1775
|
+
/** 多参数匹配时的判定逻辑, 默认为And */
|
|
1776
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1777
|
+
/** 返回结果包含抄送人列表 */
|
|
1778
|
+
withCcTo?: boolean;
|
|
1779
|
+
/** 返回结果包含表单结构 */
|
|
1780
|
+
withForm?: boolean;
|
|
1781
|
+
/** 返回结果包含表单数据 */
|
|
1782
|
+
withFormData?: boolean;
|
|
1783
|
+
/** 返回结果包含任务的表单结构 */
|
|
1784
|
+
withTaskForm?: boolean;
|
|
1785
|
+
/** 返回结果包含任务的表单数据 */
|
|
1786
|
+
withTaskFormData?: boolean;
|
|
1787
|
+
/** 返回结果包含用户任务已读情况。前提必须包含任务列表 */
|
|
1788
|
+
withTaskReads?: boolean;
|
|
1789
|
+
/** 返回结果包含任务列表 */
|
|
1790
|
+
withTasks?: boolean;
|
|
1791
|
+
}
|
|
1792
|
+
export declare class GetQueryEventSubscribeRuleParams {
|
|
1793
|
+
department?: string;
|
|
1794
|
+
enable?: boolean;
|
|
1795
|
+
id?: string;
|
|
1796
|
+
orderBy?: string[];
|
|
1797
|
+
/** @format int32 */
|
|
1798
|
+
pageIndex?: number;
|
|
1799
|
+
/** @format int32 */
|
|
1800
|
+
pageSize?: number;
|
|
1801
|
+
}
|
|
1802
|
+
export declare class TaskParams {
|
|
1803
|
+
/** 审批人。支持多选 */
|
|
1804
|
+
assignee?: string[];
|
|
1805
|
+
/** 审批人或候选人。支持多选 */
|
|
1806
|
+
assigneeOrCandidate?: string[];
|
|
1807
|
+
/** 等同于processUid */
|
|
1808
|
+
businessKey?: string;
|
|
1809
|
+
/** 候选审批人。支持多选 */
|
|
1810
|
+
candidate?: string[];
|
|
1811
|
+
/** 抄送人。不支持多选 */
|
|
1812
|
+
ccToUser?: string;
|
|
1813
|
+
/**
|
|
1814
|
+
* 任务创建时间起始
|
|
1815
|
+
* @format int64
|
|
1816
|
+
*/
|
|
1817
|
+
createdDateFrom?: number;
|
|
1818
|
+
/**
|
|
1819
|
+
* 任务创建时间截止
|
|
1820
|
+
* @format int64
|
|
1821
|
+
*/
|
|
1822
|
+
createdDateTo?: number;
|
|
1823
|
+
/** 流程关联部门代码。支持多选 */
|
|
1824
|
+
department?: string[];
|
|
1825
|
+
/** 是否按当前用户管理部门查询 */
|
|
1826
|
+
filterByAdminDepartment?: boolean;
|
|
1827
|
+
/** 包含子部门 */
|
|
1828
|
+
includeSubDepartment?: boolean;
|
|
1829
|
+
orderBy?: string[];
|
|
1830
|
+
/** @format int32 */
|
|
1831
|
+
pageIndex?: number;
|
|
1832
|
+
/** @format int32 */
|
|
1833
|
+
pageSize?: number;
|
|
1834
|
+
/** 流程模版ID */
|
|
1835
|
+
processDefinitionId?: string;
|
|
1836
|
+
/** 流程模版KEY。支持多选 */
|
|
1837
|
+
processDefinitionKey?: string[];
|
|
1838
|
+
/** 流程ID */
|
|
1839
|
+
processInstanceId?: string;
|
|
1840
|
+
/**
|
|
1841
|
+
* 流程启动时间起始
|
|
1842
|
+
* @format int64
|
|
1843
|
+
*/
|
|
1844
|
+
processStartDateFrom?: number;
|
|
1845
|
+
/**
|
|
1846
|
+
* 流程启动时间截止
|
|
1847
|
+
* @format int64
|
|
1848
|
+
*/
|
|
1849
|
+
processStartDateTo?: number;
|
|
1850
|
+
/** 流程创建用户 */
|
|
1851
|
+
processStartUser?: string;
|
|
1852
|
+
/** 流程状态。支持多选 */
|
|
1853
|
+
processStatus?: string[];
|
|
1854
|
+
/** 流程UID */
|
|
1855
|
+
processUid?: string;
|
|
1856
|
+
/** 流程多参数匹配时的判定逻辑, 默认为And */
|
|
1857
|
+
processVariablesMatchCondition?: "And" | "Or";
|
|
1858
|
+
/** 任务节点KEY。支持多选 */
|
|
1859
|
+
taskDefinitionKey?: string[];
|
|
1860
|
+
/** 任务节点KEY排除。支持多选 */
|
|
1861
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1862
|
+
/** 任务节点状态。支持多选 */
|
|
1863
|
+
taskStatus?: string[];
|
|
1864
|
+
/** 任务多参数匹配时的判定逻辑, 默认为And */
|
|
1865
|
+
variablesMatchCondition?: "And" | "Or";
|
|
1866
|
+
/** 返回结果包含任务节点表单结构 */
|
|
1867
|
+
withForm?: boolean;
|
|
1868
|
+
/** 返回结果包含任务节点表单数据 */
|
|
1869
|
+
withFormData?: boolean;
|
|
1870
|
+
/** 返回结果包含流程表单数据 */
|
|
1871
|
+
withProcessFormData?: boolean;
|
|
1872
|
+
/** 返回结果包含用户任务已读情况 */
|
|
1873
|
+
withTaskReads?: boolean;
|
|
1874
|
+
}
|
|
1875
|
+
export declare class AssigneeOrCandidateParams {
|
|
1876
|
+
/** 审批人或候选人。不支持多选! */
|
|
1877
|
+
assigneeOrCandidate: string;
|
|
1878
|
+
/** 等同于processUid */
|
|
1879
|
+
businessKey?: string;
|
|
1880
|
+
/**
|
|
1881
|
+
* 任务创建时间起始
|
|
1882
|
+
* @format int64
|
|
1883
|
+
*/
|
|
1884
|
+
createdDateFrom?: number;
|
|
1885
|
+
/**
|
|
1886
|
+
* 任务创建时间截止
|
|
1887
|
+
* @format int64
|
|
1888
|
+
*/
|
|
1889
|
+
createdDateTo?: number;
|
|
1890
|
+
/** 流程关联部门代码。支持多选 */
|
|
1891
|
+
department?: string[];
|
|
1892
|
+
/** 是否按当前用户管理部门查询 */
|
|
1893
|
+
filterByAdminDepartment?: boolean;
|
|
1894
|
+
/** 包含子部门 */
|
|
1895
|
+
includeSubDepartment?: boolean;
|
|
1896
|
+
/** 流程模版ID */
|
|
1897
|
+
processDefinitionId?: string;
|
|
1898
|
+
/** 流程模版KEY。支持多选 */
|
|
1899
|
+
processDefinitionKey?: string[];
|
|
1900
|
+
/** 流程ID */
|
|
1901
|
+
processInstanceId?: string;
|
|
1902
|
+
/**
|
|
1903
|
+
* 流程启动时间起始
|
|
1904
|
+
* @format int64
|
|
1905
|
+
*/
|
|
1906
|
+
processStartDateFrom?: number;
|
|
1907
|
+
/**
|
|
1908
|
+
* 流程启动时间截止
|
|
1909
|
+
* @format int64
|
|
1910
|
+
*/
|
|
1911
|
+
processStartDateTo?: number;
|
|
1912
|
+
/** 流程创建用户 */
|
|
1913
|
+
processStartUser?: string;
|
|
1914
|
+
/** 流程UID */
|
|
1915
|
+
processUid?: string;
|
|
1916
|
+
/** 任务节点KEY。支持多选 */
|
|
1917
|
+
taskDefinitionKey?: string[];
|
|
1918
|
+
/** 任务节点KEY排除。支持多选 */
|
|
1919
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1920
|
+
/** 返回结果包含任务节点表单结构 */
|
|
1921
|
+
withForm?: boolean;
|
|
1922
|
+
/** 返回结果包含任务节点表单数据 */
|
|
1923
|
+
withFormData?: boolean;
|
|
1924
|
+
/** 返回结果包含流程表单数据 */
|
|
1925
|
+
withProcessFormData?: boolean;
|
|
1926
|
+
}
|
|
1927
|
+
export declare class AssigneeOrCandidateCountParams {
|
|
1928
|
+
/** 审批人或候选人。不支持多选! */
|
|
1929
|
+
assigneeOrCandidate: string;
|
|
1930
|
+
/** 等同于processUid */
|
|
1931
|
+
businessKey?: string;
|
|
1932
|
+
/**
|
|
1933
|
+
* 任务创建时间起始
|
|
1934
|
+
* @format int64
|
|
1935
|
+
*/
|
|
1936
|
+
createdDateFrom?: number;
|
|
1937
|
+
/**
|
|
1938
|
+
* 任务创建时间截止
|
|
1939
|
+
* @format int64
|
|
1940
|
+
*/
|
|
1941
|
+
createdDateTo?: number;
|
|
1942
|
+
/** 流程关联部门代码。支持多选 */
|
|
1943
|
+
department?: string[];
|
|
1944
|
+
/** 是否按当前用户管理部门查询 */
|
|
1945
|
+
filterByAdminDepartment?: boolean;
|
|
1946
|
+
/** 包含子部门 */
|
|
1947
|
+
includeSubDepartment?: boolean;
|
|
1948
|
+
/** 流程模版ID */
|
|
1949
|
+
processDefinitionId?: string;
|
|
1950
|
+
/** 流程模版KEY。支持多选 */
|
|
1951
|
+
processDefinitionKey?: string[];
|
|
1952
|
+
/** 流程ID */
|
|
1953
|
+
processInstanceId?: string;
|
|
1954
|
+
/**
|
|
1955
|
+
* 流程启动时间起始
|
|
1956
|
+
* @format int64
|
|
1957
|
+
*/
|
|
1958
|
+
processStartDateFrom?: number;
|
|
1959
|
+
/**
|
|
1960
|
+
* 流程启动时间截止
|
|
1961
|
+
* @format int64
|
|
1962
|
+
*/
|
|
1963
|
+
processStartDateTo?: number;
|
|
1964
|
+
/** 流程创建用户 */
|
|
1965
|
+
processStartUser?: string;
|
|
1966
|
+
/** 流程UID */
|
|
1967
|
+
processUid?: string;
|
|
1968
|
+
/** 任务节点KEY。支持多选 */
|
|
1969
|
+
taskDefinitionKey?: string[];
|
|
1970
|
+
/** 任务节点KEY排除。支持多选 */
|
|
1971
|
+
taskDefinitionKeyNotIn?: string[];
|
|
1972
|
+
/** 返回结果包含任务节点表单结构 */
|
|
1973
|
+
withForm?: boolean;
|
|
1974
|
+
/** 返回结果包含任务节点表单数据 */
|
|
1975
|
+
withFormData?: boolean;
|
|
1976
|
+
/** 返回结果包含流程表单数据 */
|
|
1977
|
+
withProcessFormData?: boolean;
|
|
1978
|
+
}
|
|
1979
|
+
export declare class CountParams10 {
|
|
1980
|
+
/** 审批人。支持多选 */
|
|
1981
|
+
assignee?: string[];
|
|
1982
|
+
/** 审批人或候选人。支持多选 */
|
|
1983
|
+
assigneeOrCandidate?: string[];
|
|
1984
|
+
/** 等同于processUid */
|
|
1985
|
+
businessKey?: string;
|
|
1986
|
+
/** 候选审批人。支持多选 */
|
|
1987
|
+
candidate?: string[];
|
|
1988
|
+
/** 抄送人。不支持多选 */
|
|
1989
|
+
ccToUser?: string;
|
|
1990
|
+
/**
|
|
1991
|
+
* 任务创建时间起始
|
|
1992
|
+
* @format int64
|
|
1993
|
+
*/
|
|
1994
|
+
createdDateFrom?: number;
|
|
1995
|
+
/**
|
|
1996
|
+
* 任务创建时间截止
|
|
1997
|
+
* @format int64
|
|
1998
|
+
*/
|
|
1999
|
+
createdDateTo?: number;
|
|
2000
|
+
/** 流程关联部门代码。支持多选 */
|
|
2001
|
+
department?: string[];
|
|
2002
|
+
/** 是否按当前用户管理部门查询 */
|
|
2003
|
+
filterByAdminDepartment?: boolean;
|
|
2004
|
+
/** 包含子部门 */
|
|
2005
|
+
includeSubDepartment?: boolean;
|
|
2006
|
+
orderBy?: string[];
|
|
2007
|
+
/** @format int32 */
|
|
2008
|
+
pageIndex?: number;
|
|
2009
|
+
/** @format int32 */
|
|
2010
|
+
pageSize?: number;
|
|
2011
|
+
/** 流程模版ID */
|
|
2012
|
+
processDefinitionId?: string;
|
|
2013
|
+
/** 流程模版KEY。支持多选 */
|
|
2014
|
+
processDefinitionKey?: string[];
|
|
2015
|
+
/** 流程ID */
|
|
2016
|
+
processInstanceId?: string;
|
|
2017
|
+
/**
|
|
2018
|
+
* 流程启动时间起始
|
|
2019
|
+
* @format int64
|
|
2020
|
+
*/
|
|
2021
|
+
processStartDateFrom?: number;
|
|
2022
|
+
/**
|
|
2023
|
+
* 流程启动时间截止
|
|
2024
|
+
* @format int64
|
|
2025
|
+
*/
|
|
2026
|
+
processStartDateTo?: number;
|
|
2027
|
+
/** 流程创建用户 */
|
|
2028
|
+
processStartUser?: string;
|
|
2029
|
+
/** 流程状态。支持多选 */
|
|
2030
|
+
processStatus?: string[];
|
|
2031
|
+
/** 流程UID */
|
|
2032
|
+
processUid?: string;
|
|
2033
|
+
/** 流程多参数匹配时的判定逻辑, 默认为And */
|
|
2034
|
+
processVariablesMatchCondition?: "And" | "Or";
|
|
2035
|
+
/** 任务节点KEY。支持多选 */
|
|
2036
|
+
taskDefinitionKey?: string[];
|
|
2037
|
+
/** 任务节点KEY排除。支持多选 */
|
|
2038
|
+
taskDefinitionKeyNotIn?: string[];
|
|
2039
|
+
/** 任务节点状态。支持多选 */
|
|
2040
|
+
taskStatus?: string[];
|
|
2041
|
+
/** 任务多参数匹配时的判定逻辑, 默认为And */
|
|
2042
|
+
variablesMatchCondition?: "And" | "Or";
|
|
2043
|
+
/** 返回结果包含任务节点表单结构 */
|
|
2044
|
+
withForm?: boolean;
|
|
2045
|
+
/** 返回结果包含任务节点表单数据 */
|
|
2046
|
+
withFormData?: boolean;
|
|
2047
|
+
/** 返回结果包含流程表单数据 */
|
|
2048
|
+
withProcessFormData?: boolean;
|
|
2049
|
+
/** 返回结果包含用户任务已读情况 */
|
|
2050
|
+
withTaskReads?: boolean;
|
|
2051
|
+
}
|
|
2052
|
+
export declare class DetailByIdParams5 {
|
|
2053
|
+
/** 返回结果包含表单结构 */
|
|
2054
|
+
withForm?: boolean;
|
|
2055
|
+
/** 返回结果包含表单数据 */
|
|
2056
|
+
withFormData?: boolean;
|
|
2057
|
+
/** 返回结果包含流程表单数据 */
|
|
2058
|
+
withProcessFormData?: boolean;
|
|
2059
|
+
/** 返回结果包含用户任务已读情况 */
|
|
2060
|
+
withTaskReads?: boolean;
|
|
2061
|
+
/** id */
|
|
2062
|
+
id: string;
|
|
2063
|
+
}
|
|
2064
|
+
import { AxiosRequestConfig, ResponseType } from "axios";
|
|
2065
|
+
export declare type QueryParamsType = Record<string | number, any>;
|
|
2066
|
+
export interface FullRequestParams extends Omit<AxiosRequestConfig, "data" | "params" | "url" | "responseType"> {
|
|
2067
|
+
/** set parameter to `true` for call `securityWorker` for this request */
|
|
2068
|
+
secure?: boolean;
|
|
2069
|
+
/** request path */
|
|
2070
|
+
url: string;
|
|
2071
|
+
/** content type of request body */
|
|
2072
|
+
type?: ContentType;
|
|
2073
|
+
/** query params */
|
|
2074
|
+
params?: QueryParamsType;
|
|
2075
|
+
/** format of response (i.e. response.json() -> format: "json") */
|
|
2076
|
+
ResponseType?: ResponseType;
|
|
2077
|
+
/** request body */
|
|
2078
|
+
body?: unknown;
|
|
2079
|
+
}
|
|
2080
|
+
export declare type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
|
|
2081
|
+
export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, "data" | "cancelToken"> {
|
|
2082
|
+
securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
|
|
2083
|
+
secure?: boolean;
|
|
2084
|
+
ResponseType?: ResponseType;
|
|
2085
|
+
}
|
|
2086
|
+
export declare enum ContentType {
|
|
2087
|
+
Json = "application/json",
|
|
2088
|
+
FormData = "multipart/form-data",
|
|
2089
|
+
UrlEncoded = "application/x-www-form-urlencoded"
|
|
2090
|
+
}
|
|
2091
|
+
interface HttpClient {
|
|
2092
|
+
request: <T = any, _E = any>(config: AxiosRequestConfig) => Promise<T>;
|
|
2093
|
+
}
|
|
2094
|
+
/**
|
|
2095
|
+
* @title 流程查询模块
|
|
2096
|
+
* @version 1.0
|
|
2097
|
+
* @baseUrl http://192.168.200.12:5000
|
|
2098
|
+
*/
|
|
2099
|
+
declare class Api {
|
|
2100
|
+
private http;
|
|
2101
|
+
constructor(http: HttpClient);
|
|
2102
|
+
manage: {
|
|
2103
|
+
/**
|
|
2104
|
+
* No description
|
|
2105
|
+
*
|
|
2106
|
+
* @tags manage
|
|
2107
|
+
* @name DroppedEvent
|
|
2108
|
+
* @summary 异常抛弃的事件数据分页查询
|
|
2109
|
+
* @request GET:/auth-bpmn-query/manage/dropped-event
|
|
2110
|
+
* @response `200` `PageResultDroppedEventEntity` OK
|
|
2111
|
+
* @response `401` `void` Unauthorized
|
|
2112
|
+
* @response `403` `void` Forbidden
|
|
2113
|
+
* @response `404` `void` Not Found
|
|
2114
|
+
*/
|
|
2115
|
+
droppedEvent: (query: DroppedEventParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultDroppedEventEntity>;
|
|
2116
|
+
/**
|
|
2117
|
+
* No description
|
|
2118
|
+
*
|
|
2119
|
+
* @tags manage
|
|
2120
|
+
* @name DroppedEventRecover
|
|
2121
|
+
* @summary 尝试重新处理时间范围内的异常事件,默认为当天
|
|
2122
|
+
* @request POST:/auth-bpmn-query/manage/dropped-event/recover
|
|
2123
|
+
* @response `200` `void` OK
|
|
2124
|
+
* @response `201` `void` Created
|
|
2125
|
+
* @response `401` `void` Unauthorized
|
|
2126
|
+
* @response `403` `void` Forbidden
|
|
2127
|
+
* @response `404` `void` Not Found
|
|
2128
|
+
*/
|
|
2129
|
+
droppedEventRecover: (query: DroppedEventRecoverParams, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2130
|
+
/**
|
|
2131
|
+
* No description
|
|
2132
|
+
*
|
|
2133
|
+
* @tags manage
|
|
2134
|
+
* @name PostDroppedEventRecoverById
|
|
2135
|
+
* @summary 尝试重新处理指定异常事件
|
|
2136
|
+
* @request POST:/auth-bpmn-query/manage/dropped-event/recover/{id}
|
|
2137
|
+
* @response `200` `void` OK
|
|
2138
|
+
* @response `201` `void` Created
|
|
2139
|
+
* @response `401` `void` Unauthorized
|
|
2140
|
+
* @response `403` `void` Forbidden
|
|
2141
|
+
* @response `404` `void` Not Found
|
|
2142
|
+
*/
|
|
2143
|
+
postDroppedEventRecoverById: (id: number, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2144
|
+
/**
|
|
2145
|
+
* No description
|
|
2146
|
+
*
|
|
2147
|
+
* @tags manage
|
|
2148
|
+
* @name DeleteDroppedEventRecoverById
|
|
2149
|
+
* @summary 删除异常事件
|
|
2150
|
+
* @request DELETE:/auth-bpmn-query/manage/dropped-event/recover/{id}
|
|
2151
|
+
* @response `200` `void` OK
|
|
2152
|
+
* @response `204` `void` No Content
|
|
2153
|
+
* @response `401` `void` Unauthorized
|
|
2154
|
+
* @response `403` `void` Forbidden
|
|
2155
|
+
*/
|
|
2156
|
+
deleteDroppedEventRecoverById: (id: number, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2157
|
+
/**
|
|
2158
|
+
* No description
|
|
2159
|
+
*
|
|
2160
|
+
* @tags manage
|
|
2161
|
+
* @name CacheClear
|
|
2162
|
+
* @summary 清除全部缓存
|
|
2163
|
+
* @request GET:/auth-bpmn-query/manage/cache-clear
|
|
2164
|
+
* @response `200` `void` OK
|
|
2165
|
+
* @response `401` `void` Unauthorized
|
|
2166
|
+
* @response `403` `void` Forbidden
|
|
2167
|
+
* @response `404` `void` Not Found
|
|
2168
|
+
*/
|
|
2169
|
+
cacheClear: (axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2170
|
+
/**
|
|
2171
|
+
* No description
|
|
2172
|
+
*
|
|
2173
|
+
* @tags manage
|
|
2174
|
+
* @name CacheClearByName
|
|
2175
|
+
* @summary 清除缓存
|
|
2176
|
+
* @request GET:/auth-bpmn-query/manage/cache-clear/{name}
|
|
2177
|
+
* @response `200` `void` OK
|
|
2178
|
+
* @response `401` `void` Unauthorized
|
|
2179
|
+
* @response `403` `void` Forbidden
|
|
2180
|
+
* @response `404` `void` Not Found
|
|
2181
|
+
*/
|
|
2182
|
+
cacheClearByName: (name: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2183
|
+
/**
|
|
2184
|
+
* No description
|
|
2185
|
+
*
|
|
2186
|
+
* @tags manage
|
|
2187
|
+
* @name CacheClearByNameAndKey
|
|
2188
|
+
* @summary 清除指定key的缓存项目
|
|
2189
|
+
* @request GET:/auth-bpmn-query/manage/cache-clear/{name}/{key}
|
|
2190
|
+
* @response `200` `void` OK
|
|
2191
|
+
* @response `401` `void` Unauthorized
|
|
2192
|
+
* @response `403` `void` Forbidden
|
|
2193
|
+
* @response `404` `void` Not Found
|
|
2194
|
+
*/
|
|
2195
|
+
cacheClearByNameAndKey: (name: string, key: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2196
|
+
/**
|
|
2197
|
+
* No description
|
|
2198
|
+
*
|
|
2199
|
+
* @tags manage
|
|
2200
|
+
* @name CacheRefreshByNameAndKey
|
|
2201
|
+
* @summary 重新加载指定key的缓存项目
|
|
2202
|
+
* @request GET:/auth-bpmn-query/manage/cache-refresh/{name}/{key}
|
|
2203
|
+
* @response `200` `void` OK
|
|
2204
|
+
* @response `401` `void` Unauthorized
|
|
2205
|
+
* @response `403` `void` Forbidden
|
|
2206
|
+
* @response `404` `void` Not Found
|
|
2207
|
+
*/
|
|
2208
|
+
cacheRefreshByNameAndKey: (name: string, key: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2209
|
+
/**
|
|
2210
|
+
* No description
|
|
2211
|
+
*
|
|
2212
|
+
* @tags manage
|
|
2213
|
+
* @name CacheStats
|
|
2214
|
+
* @summary getCacheStats
|
|
2215
|
+
* @request GET:/auth-bpmn-query/manage/cache-stats
|
|
2216
|
+
* @response `200` `Record<string, CacheStatsInfo>` OK
|
|
2217
|
+
* @response `401` `void` Unauthorized
|
|
2218
|
+
* @response `403` `void` Forbidden
|
|
2219
|
+
* @response `404` `void` Not Found
|
|
2220
|
+
*/
|
|
2221
|
+
cacheStats: (axiosConfig?: AxiosRequestConfig) => Promise<Record<string, CacheStatsInfo>>;
|
|
2222
|
+
/**
|
|
2223
|
+
* No description
|
|
2224
|
+
*
|
|
2225
|
+
* @tags manage
|
|
2226
|
+
* @name HistoryCumulateCount
|
|
2227
|
+
* @summary listCumulateCount
|
|
2228
|
+
* @request GET:/auth-bpmn-query/manage/history/cumulate-count
|
|
2229
|
+
* @response `200` `(CountData)[]` OK
|
|
2230
|
+
* @response `401` `void` Unauthorized
|
|
2231
|
+
* @response `403` `void` Forbidden
|
|
2232
|
+
* @response `404` `void` Not Found
|
|
2233
|
+
*/
|
|
2234
|
+
historyCumulateCount: (query: HistoryCumulateCountParams, axiosConfig?: AxiosRequestConfig) => Promise<CountData[]>;
|
|
2235
|
+
/**
|
|
2236
|
+
* No description
|
|
2237
|
+
*
|
|
2238
|
+
* @tags manage
|
|
2239
|
+
* @name HistoryWaitingCount
|
|
2240
|
+
* @summary listWaitingCount
|
|
2241
|
+
* @request GET:/auth-bpmn-query/manage/history/waiting-count
|
|
2242
|
+
* @response `200` `(CountData)[]` OK
|
|
2243
|
+
* @response `401` `void` Unauthorized
|
|
2244
|
+
* @response `403` `void` Forbidden
|
|
2245
|
+
* @response `404` `void` Not Found
|
|
2246
|
+
*/
|
|
2247
|
+
historyWaitingCount: (query: HistoryWaitingCountParams, axiosConfig?: AxiosRequestConfig) => Promise<CountData[]>;
|
|
2248
|
+
/**
|
|
2249
|
+
* No description
|
|
2250
|
+
*
|
|
2251
|
+
* @tags manage
|
|
2252
|
+
* @name HistoryWaitingCountReset
|
|
2253
|
+
* @summary resetWaitingCount
|
|
2254
|
+
* @request POST:/auth-bpmn-query/manage/history/waiting-count/reset
|
|
2255
|
+
* @response `200` `void` OK
|
|
2256
|
+
* @response `201` `void` Created
|
|
2257
|
+
* @response `401` `void` Unauthorized
|
|
2258
|
+
* @response `403` `void` Forbidden
|
|
2259
|
+
* @response `404` `void` Not Found
|
|
2260
|
+
*/
|
|
2261
|
+
historyWaitingCountReset: (axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2262
|
+
/**
|
|
2263
|
+
* No description
|
|
2264
|
+
*
|
|
2265
|
+
* @tags manage
|
|
2266
|
+
* @name PutProcessStatusByIdAndStatus
|
|
2267
|
+
* @summary putProcessStatus
|
|
2268
|
+
* @request PUT:/auth-bpmn-query/manage/process/{id}/status/{status}
|
|
2269
|
+
* @response `200` `void` OK
|
|
2270
|
+
* @response `201` `void` Created
|
|
2271
|
+
* @response `401` `void` Unauthorized
|
|
2272
|
+
* @response `403` `void` Forbidden
|
|
2273
|
+
* @response `404` `void` Not Found
|
|
2274
|
+
*/
|
|
2275
|
+
putProcessStatusByIdAndStatus: (id: string, status: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2276
|
+
/**
|
|
2277
|
+
* No description
|
|
2278
|
+
*
|
|
2279
|
+
* @tags manage
|
|
2280
|
+
* @name StatusHandlingCount
|
|
2281
|
+
* @summary getEventHandlingCount
|
|
2282
|
+
* @request GET:/auth-bpmn-query/manage/status/handling-count
|
|
2283
|
+
* @response `200` `number` OK
|
|
2284
|
+
* @response `401` `void` Unauthorized
|
|
2285
|
+
* @response `403` `void` Forbidden
|
|
2286
|
+
* @response `404` `void` Not Found
|
|
2287
|
+
*/
|
|
2288
|
+
statusHandlingCount: (axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2289
|
+
/**
|
|
2290
|
+
* No description
|
|
2291
|
+
*
|
|
2292
|
+
* @tags manage
|
|
2293
|
+
* @name PutTaskStatusByIdAndStatus
|
|
2294
|
+
* @summary putTaskStatus
|
|
2295
|
+
* @request PUT:/auth-bpmn-query/manage/task/{id}/status/{status}
|
|
2296
|
+
* @response `200` `void` OK
|
|
2297
|
+
* @response `201` `void` Created
|
|
2298
|
+
* @response `401` `void` Unauthorized
|
|
2299
|
+
* @response `403` `void` Forbidden
|
|
2300
|
+
* @response `404` `void` Not Found
|
|
2301
|
+
*/
|
|
2302
|
+
putTaskStatusByIdAndStatus: (id: string, status: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2303
|
+
/**
|
|
2304
|
+
* No description
|
|
2305
|
+
*
|
|
2306
|
+
* @tags manage
|
|
2307
|
+
* @name GetQueryEventSubscribeRule
|
|
2308
|
+
* @summary 列出消息订阅规则
|
|
2309
|
+
* @request GET:/auth-bpmn-query/manage/query-event-subscribe-rule
|
|
2310
|
+
* @response `200` `PageResultSubscribeRule` OK
|
|
2311
|
+
* @response `401` `void` Unauthorized
|
|
2312
|
+
* @response `403` `void` Forbidden
|
|
2313
|
+
* @response `404` `void` Not Found
|
|
2314
|
+
*/
|
|
2315
|
+
getQueryEventSubscribeRule: (query: GetQueryEventSubscribeRuleParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultSubscribeRule>;
|
|
2316
|
+
/**
|
|
2317
|
+
* No description
|
|
2318
|
+
*
|
|
2319
|
+
* @tags manage
|
|
2320
|
+
* @name PostQueryEventSubscribeRule
|
|
2321
|
+
* @summary 保存或修改规则
|
|
2322
|
+
* @request POST:/auth-bpmn-query/manage/query-event-subscribe-rule
|
|
2323
|
+
* @response `200` `string` OK
|
|
2324
|
+
* @response `201` `void` Created
|
|
2325
|
+
* @response `401` `void` Unauthorized
|
|
2326
|
+
* @response `403` `void` Forbidden
|
|
2327
|
+
* @response `404` `void` Not Found
|
|
2328
|
+
*/
|
|
2329
|
+
postQueryEventSubscribeRule: (data: SubscribeRuleReq, axiosConfig?: AxiosRequestConfig) => Promise<string>;
|
|
2330
|
+
/**
|
|
2331
|
+
* No description
|
|
2332
|
+
*
|
|
2333
|
+
* @tags manage
|
|
2334
|
+
* @name DeleteQueryEventSubscribeRuleById
|
|
2335
|
+
* @summary 删除规则
|
|
2336
|
+
* @request DELETE:/auth-bpmn-query/manage/query-event-subscribe-rule/{id}
|
|
2337
|
+
* @response `200` `void` OK
|
|
2338
|
+
* @response `204` `void` No Content
|
|
2339
|
+
* @response `401` `void` Unauthorized
|
|
2340
|
+
* @response `403` `void` Forbidden
|
|
2341
|
+
*/
|
|
2342
|
+
deleteQueryEventSubscribeRuleById: (id: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2343
|
+
/**
|
|
2344
|
+
* No description
|
|
2345
|
+
*
|
|
2346
|
+
* @tags manage
|
|
2347
|
+
* @name QueryEventSubscribeRuleSubscribersById
|
|
2348
|
+
* @summary 查看规则下的用户列表
|
|
2349
|
+
* @request GET:/auth-bpmn-query/manage/query-event-subscribe-rule/{id}/subscribers
|
|
2350
|
+
* @response `200` `(string)[]` OK
|
|
2351
|
+
* @response `401` `void` Unauthorized
|
|
2352
|
+
* @response `403` `void` Forbidden
|
|
2353
|
+
* @response `404` `void` Not Found
|
|
2354
|
+
*/
|
|
2355
|
+
queryEventSubscribeRuleSubscribersById: (id: string, axiosConfig?: AxiosRequestConfig) => Promise<string[]>;
|
|
2356
|
+
};
|
|
2357
|
+
inner: {
|
|
2358
|
+
/**
|
|
2359
|
+
* No description
|
|
2360
|
+
*
|
|
2361
|
+
* @tags inner
|
|
2362
|
+
* @name FormDataProcessFormDataById
|
|
2363
|
+
* @summary getProcessFormData
|
|
2364
|
+
* @request GET:/auth-bpmn-query/inner/form-data/process/{id}/form-data
|
|
2365
|
+
* @response `200` `Number` OK
|
|
2366
|
+
* @response `401` `void` Unauthorized
|
|
2367
|
+
* @response `403` `void` Forbidden
|
|
2368
|
+
* @response `404` `void` Not Found
|
|
2369
|
+
*/
|
|
2370
|
+
formDataProcessFormDataById: (id: string, axiosConfig?: AxiosRequestConfig) => Promise<any>;
|
|
2371
|
+
/**
|
|
2372
|
+
* No description
|
|
2373
|
+
*
|
|
2374
|
+
* @tags inner
|
|
2375
|
+
* @name DoMigration
|
|
2376
|
+
* @summary doMigration
|
|
2377
|
+
* @request POST:/auth-bpmn-query/inner/do-migration
|
|
2378
|
+
* @response `200` `number` OK
|
|
2379
|
+
* @response `201` `void` Created
|
|
2380
|
+
* @response `401` `void` Unauthorized
|
|
2381
|
+
* @response `403` `void` Forbidden
|
|
2382
|
+
* @response `404` `void` Not Found
|
|
2383
|
+
*/
|
|
2384
|
+
doMigration: (query: DoMigrationParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2385
|
+
/**
|
|
2386
|
+
* No description
|
|
2387
|
+
*
|
|
2388
|
+
* @tags inner
|
|
2389
|
+
* @name MigrationClearScheduleToggle
|
|
2390
|
+
* @summary toggleMigrationClearSchedule
|
|
2391
|
+
* @request POST:/auth-bpmn-query/inner/migration-clear-schedule-toggle
|
|
2392
|
+
* @response `200` `boolean` OK
|
|
2393
|
+
* @response `201` `void` Created
|
|
2394
|
+
* @response `401` `void` Unauthorized
|
|
2395
|
+
* @response `403` `void` Forbidden
|
|
2396
|
+
* @response `404` `void` Not Found
|
|
2397
|
+
*/
|
|
2398
|
+
migrationClearScheduleToggle: (query: MigrationClearScheduleToggleParams, axiosConfig?: AxiosRequestConfig) => Promise<boolean>;
|
|
2399
|
+
/**
|
|
2400
|
+
* No description
|
|
2401
|
+
*
|
|
2402
|
+
* @tags inner
|
|
2403
|
+
* @name MigrationScheduleToggle
|
|
2404
|
+
* @summary toggleMigrationSchedule
|
|
2405
|
+
* @request POST:/auth-bpmn-query/inner/migration-schedule-toggle
|
|
2406
|
+
* @response `200` `boolean` OK
|
|
2407
|
+
* @response `201` `void` Created
|
|
2408
|
+
* @response `401` `void` Unauthorized
|
|
2409
|
+
* @response `403` `void` Forbidden
|
|
2410
|
+
* @response `404` `void` Not Found
|
|
2411
|
+
*/
|
|
2412
|
+
migrationScheduleToggle: (query: MigrationScheduleToggleParams, axiosConfig?: AxiosRequestConfig) => Promise<boolean>;
|
|
2413
|
+
};
|
|
2414
|
+
integrationContext: {
|
|
2415
|
+
/**
|
|
2416
|
+
* No description
|
|
2417
|
+
*
|
|
2418
|
+
* @tags integrationContext
|
|
2419
|
+
* @name IntegrationContext
|
|
2420
|
+
* @summary 服务任务执行记录分页查询
|
|
2421
|
+
* @request GET:/auth-bpmn-query/integration-context
|
|
2422
|
+
* @response `200` `PageResultIntegrationContext` OK
|
|
2423
|
+
* @response `401` `void` Unauthorized
|
|
2424
|
+
* @response `403` `void` Forbidden
|
|
2425
|
+
* @response `404` `void` Not Found
|
|
2426
|
+
*/
|
|
2427
|
+
integrationContext: (query: IntegrationContextParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultIntegrationContext>;
|
|
2428
|
+
};
|
|
2429
|
+
process: {
|
|
2430
|
+
/**
|
|
2431
|
+
* @description 所需权限:bpmn:process:basic
|
|
2432
|
+
*
|
|
2433
|
+
* @tags process
|
|
2434
|
+
* @name Process
|
|
2435
|
+
* @summary 通用流程查询
|
|
2436
|
+
* @request GET:/auth-bpmn-query/process
|
|
2437
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2438
|
+
* @response `401` `void` Unauthorized
|
|
2439
|
+
* @response `403` `void` Forbidden
|
|
2440
|
+
* @response `404` `void` Not Found
|
|
2441
|
+
*/
|
|
2442
|
+
process: (query: ProcessParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2443
|
+
/**
|
|
2444
|
+
* No description
|
|
2445
|
+
*
|
|
2446
|
+
* @tags process
|
|
2447
|
+
* @name CandidateForMe
|
|
2448
|
+
* @summary 当前用户为候选人的流程
|
|
2449
|
+
* @request GET:/auth-bpmn-query/process/candidate-for-me
|
|
2450
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2451
|
+
* @response `401` `void` Unauthorized
|
|
2452
|
+
* @response `403` `void` Forbidden
|
|
2453
|
+
* @response `404` `void` Not Found
|
|
2454
|
+
*/
|
|
2455
|
+
candidateForMe: (query: CandidateForMeParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2456
|
+
/**
|
|
2457
|
+
* No description
|
|
2458
|
+
*
|
|
2459
|
+
* @tags process
|
|
2460
|
+
* @name CandidateForMeCount
|
|
2461
|
+
* @summary 当前用户为候选人的流程[数量]
|
|
2462
|
+
* @request GET:/auth-bpmn-query/process/candidate-for-me/count
|
|
2463
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2464
|
+
* @response `401` `void` Unauthorized
|
|
2465
|
+
* @response `403` `void` Forbidden
|
|
2466
|
+
* @response `404` `void` Not Found
|
|
2467
|
+
*/
|
|
2468
|
+
candidateForMeCount: (query: CandidateForMeCountParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2469
|
+
/**
|
|
2470
|
+
* No description
|
|
2471
|
+
*
|
|
2472
|
+
* @tags process
|
|
2473
|
+
* @name CcToMe
|
|
2474
|
+
* @summary 抄送当前用户的流程
|
|
2475
|
+
* @request GET:/auth-bpmn-query/process/cc-to-me
|
|
2476
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2477
|
+
* @response `401` `void` Unauthorized
|
|
2478
|
+
* @response `403` `void` Forbidden
|
|
2479
|
+
* @response `404` `void` Not Found
|
|
2480
|
+
*/
|
|
2481
|
+
ccToMe: (query: CcToMeParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2482
|
+
/**
|
|
2483
|
+
* No description
|
|
2484
|
+
*
|
|
2485
|
+
* @tags process
|
|
2486
|
+
* @name CcToMeCount
|
|
2487
|
+
* @summary 抄送当前用户的流程[数量]
|
|
2488
|
+
* @request GET:/auth-bpmn-query/process/cc-to-me/count
|
|
2489
|
+
* @response `200` `number` OK
|
|
2490
|
+
* @response `401` `void` Unauthorized
|
|
2491
|
+
* @response `403` `void` Forbidden
|
|
2492
|
+
* @response `404` `void` Not Found
|
|
2493
|
+
*/
|
|
2494
|
+
ccToMeCount: (query: CcToMeCountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2495
|
+
/**
|
|
2496
|
+
* No description
|
|
2497
|
+
*
|
|
2498
|
+
* @tags process
|
|
2499
|
+
* @name CompletedByMe
|
|
2500
|
+
* @summary 当前用户审批过的流程
|
|
2501
|
+
* @request GET:/auth-bpmn-query/process/completed-by-me
|
|
2502
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2503
|
+
* @response `401` `void` Unauthorized
|
|
2504
|
+
* @response `403` `void` Forbidden
|
|
2505
|
+
* @response `404` `void` Not Found
|
|
2506
|
+
*/
|
|
2507
|
+
completedByMe: (query: CompletedByMeParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2508
|
+
/**
|
|
2509
|
+
* No description
|
|
2510
|
+
*
|
|
2511
|
+
* @tags process
|
|
2512
|
+
* @name CompletedByMeCount
|
|
2513
|
+
* @summary 当前用户审批过的流程[数量]
|
|
2514
|
+
* @request GET:/auth-bpmn-query/process/completed-by-me/count
|
|
2515
|
+
* @response `200` `number` OK
|
|
2516
|
+
* @response `401` `void` Unauthorized
|
|
2517
|
+
* @response `403` `void` Forbidden
|
|
2518
|
+
* @response `404` `void` Not Found
|
|
2519
|
+
*/
|
|
2520
|
+
completedByMeCount: (query: CompletedByMeCountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2521
|
+
/**
|
|
2522
|
+
* @description 所需权限:bpmn:process:basic
|
|
2523
|
+
*
|
|
2524
|
+
* @tags process
|
|
2525
|
+
* @name Count
|
|
2526
|
+
* @summary 通用流程查询(数量)
|
|
2527
|
+
* @request GET:/auth-bpmn-query/process/count
|
|
2528
|
+
* @response `200` `number` OK
|
|
2529
|
+
* @response `401` `void` Unauthorized
|
|
2530
|
+
* @response `403` `void` Forbidden
|
|
2531
|
+
* @response `404` `void` Not Found
|
|
2532
|
+
*/
|
|
2533
|
+
count: (query: CountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2534
|
+
/**
|
|
2535
|
+
* No description
|
|
2536
|
+
*
|
|
2537
|
+
* @tags process
|
|
2538
|
+
* @name DetailByUidByUid
|
|
2539
|
+
* @summary 流程详情查询(按businessKey/uid)
|
|
2540
|
+
* @request GET:/auth-bpmn-query/process/detail-by-uid/{uid}
|
|
2541
|
+
* @response `200` `ProcessDTO` OK
|
|
2542
|
+
* @response `401` `void` Unauthorized
|
|
2543
|
+
* @response `403` `void` Forbidden
|
|
2544
|
+
* @response `404` `void` Not Found
|
|
2545
|
+
*/
|
|
2546
|
+
detailByUidByUid: ({ uid, ...query }: DetailByUidByUidParams, axiosConfig?: AxiosRequestConfig) => Promise<ProcessDTO>;
|
|
2547
|
+
/**
|
|
2548
|
+
* No description
|
|
2549
|
+
*
|
|
2550
|
+
* @tags process
|
|
2551
|
+
* @name DetailById
|
|
2552
|
+
* @summary 流程详情查询
|
|
2553
|
+
* @request GET:/auth-bpmn-query/process/detail/{id}
|
|
2554
|
+
* @response `200` `ProcessDTO` OK
|
|
2555
|
+
* @response `401` `void` Unauthorized
|
|
2556
|
+
* @response `403` `void` Forbidden
|
|
2557
|
+
* @response `404` `void` Not Found
|
|
2558
|
+
*/
|
|
2559
|
+
detailById: ({ id, ...query }: DetailByIdParams, axiosConfig?: AxiosRequestConfig) => Promise<ProcessDTO>;
|
|
2560
|
+
/**
|
|
2561
|
+
* No description
|
|
2562
|
+
*
|
|
2563
|
+
* @tags process
|
|
2564
|
+
* @name InvolvedByMe
|
|
2565
|
+
* @summary 当前用户参与的流程(流程发起人或审批人)
|
|
2566
|
+
* @request GET:/auth-bpmn-query/process/involved-by-me
|
|
2567
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2568
|
+
* @response `401` `void` Unauthorized
|
|
2569
|
+
* @response `403` `void` Forbidden
|
|
2570
|
+
* @response `404` `void` Not Found
|
|
2571
|
+
*/
|
|
2572
|
+
involvedByMe: (query: InvolvedByMeParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2573
|
+
/**
|
|
2574
|
+
* No description
|
|
2575
|
+
*
|
|
2576
|
+
* @tags process
|
|
2577
|
+
* @name InvolvedByMeCount
|
|
2578
|
+
* @summary 当前用户参与的流程[数量]
|
|
2579
|
+
* @request GET:/auth-bpmn-query/process/involved-by-me/count
|
|
2580
|
+
* @response `200` `number` OK
|
|
2581
|
+
* @response `401` `void` Unauthorized
|
|
2582
|
+
* @response `403` `void` Forbidden
|
|
2583
|
+
* @response `404` `void` Not Found
|
|
2584
|
+
*/
|
|
2585
|
+
involvedByMeCount: (query: InvolvedByMeCountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2586
|
+
/**
|
|
2587
|
+
* No description
|
|
2588
|
+
*
|
|
2589
|
+
* @tags process
|
|
2590
|
+
* @name List
|
|
2591
|
+
* @summary 根据流程ID获取流程详情列表
|
|
2592
|
+
* @request GET:/auth-bpmn-query/process/list
|
|
2593
|
+
* @response `200` `(ProcessDTO)[]` OK
|
|
2594
|
+
* @response `401` `void` Unauthorized
|
|
2595
|
+
* @response `403` `void` Forbidden
|
|
2596
|
+
* @response `404` `void` Not Found
|
|
2597
|
+
*/
|
|
2598
|
+
list: (query: ListParams, axiosConfig?: AxiosRequestConfig) => Promise<ProcessDTO[]>;
|
|
2599
|
+
/**
|
|
2600
|
+
* No description
|
|
2601
|
+
*
|
|
2602
|
+
* @tags process
|
|
2603
|
+
* @name SubmitByMe
|
|
2604
|
+
* @summary 当前用户发起的流程
|
|
2605
|
+
* @request GET:/auth-bpmn-query/process/submit-by-me
|
|
2606
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2607
|
+
* @response `401` `void` Unauthorized
|
|
2608
|
+
* @response `403` `void` Forbidden
|
|
2609
|
+
* @response `404` `void` Not Found
|
|
2610
|
+
*/
|
|
2611
|
+
submitByMe: (query: SubmitByMeParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2612
|
+
/**
|
|
2613
|
+
* No description
|
|
2614
|
+
*
|
|
2615
|
+
* @tags process
|
|
2616
|
+
* @name SubmitByMeCount
|
|
2617
|
+
* @summary 当前用户发起的流程[数量]
|
|
2618
|
+
* @request GET:/auth-bpmn-query/process/submit-by-me/count
|
|
2619
|
+
* @response `200` `number` OK
|
|
2620
|
+
* @response `401` `void` Unauthorized
|
|
2621
|
+
* @response `403` `void` Forbidden
|
|
2622
|
+
* @response `404` `void` Not Found
|
|
2623
|
+
*/
|
|
2624
|
+
submitByMeCount: (query: SubmitByMeCountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2625
|
+
/**
|
|
2626
|
+
* No description
|
|
2627
|
+
*
|
|
2628
|
+
* @tags process
|
|
2629
|
+
* @name WaitingForMe
|
|
2630
|
+
* @summary 待当前用户审批的流程
|
|
2631
|
+
* @request GET:/auth-bpmn-query/process/waiting-for-me
|
|
2632
|
+
* @response `200` `PageResultProcessDTO` OK
|
|
2633
|
+
* @response `401` `void` Unauthorized
|
|
2634
|
+
* @response `403` `void` Forbidden
|
|
2635
|
+
* @response `404` `void` Not Found
|
|
2636
|
+
*/
|
|
2637
|
+
waitingForMe: (query: WaitingForMeParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessDTO>;
|
|
2638
|
+
/**
|
|
2639
|
+
* No description
|
|
2640
|
+
*
|
|
2641
|
+
* @tags process
|
|
2642
|
+
* @name WaitingForMeCount
|
|
2643
|
+
* @summary 待用户审批的流程[数量]
|
|
2644
|
+
* @request GET:/auth-bpmn-query/process/waiting-for-me/count
|
|
2645
|
+
* @response `200` `number` OK
|
|
2646
|
+
* @response `401` `void` Unauthorized
|
|
2647
|
+
* @response `403` `void` Forbidden
|
|
2648
|
+
* @response `404` `void` Not Found
|
|
2649
|
+
*/
|
|
2650
|
+
waitingForMeCount: (query: WaitingForMeCountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2651
|
+
};
|
|
2652
|
+
taskCount: {
|
|
2653
|
+
/**
|
|
2654
|
+
* No description
|
|
2655
|
+
*
|
|
2656
|
+
* @tags taskCount
|
|
2657
|
+
* @name DemoDemoByPattern
|
|
2658
|
+
* @summary 测试获取不为空的rediskey
|
|
2659
|
+
* @request GET:/auth-bpmn-query/task-count/demo/demo/{pattern}
|
|
2660
|
+
* @response `200` `(string)[]` OK
|
|
2661
|
+
* @response `401` `void` Unauthorized
|
|
2662
|
+
* @response `403` `void` Forbidden
|
|
2663
|
+
* @response `404` `void` Not Found
|
|
2664
|
+
*/
|
|
2665
|
+
demoDemoByPattern: (pattern: string, axiosConfig?: AxiosRequestConfig) => Promise<string[]>;
|
|
2666
|
+
/**
|
|
2667
|
+
* No description
|
|
2668
|
+
*
|
|
2669
|
+
* @tags taskCount
|
|
2670
|
+
* @name DemoKeyByKey
|
|
2671
|
+
* @summary 根据redis key查询
|
|
2672
|
+
* @request GET:/auth-bpmn-query/task-count/demo/key/{key}
|
|
2673
|
+
* @response `200` `(string)[]` OK
|
|
2674
|
+
* @response `401` `void` Unauthorized
|
|
2675
|
+
* @response `403` `void` Forbidden
|
|
2676
|
+
* @response `404` `void` Not Found
|
|
2677
|
+
*/
|
|
2678
|
+
demoKeyByKey: (key: string, axiosConfig?: AxiosRequestConfig) => Promise<string[]>;
|
|
2679
|
+
/**
|
|
2680
|
+
* No description
|
|
2681
|
+
*
|
|
2682
|
+
* @tags taskCount
|
|
2683
|
+
* @name PostRedisRecord
|
|
2684
|
+
* @summary 获取用户处理中的流程Id, 任务Id
|
|
2685
|
+
* @request POST:/auth-bpmn-query/task-count/redis-record
|
|
2686
|
+
* @response `200` `FindRedisRecordResponse` OK
|
|
2687
|
+
* @response `201` `void` Created
|
|
2688
|
+
* @response `401` `void` Unauthorized
|
|
2689
|
+
* @response `403` `void` Forbidden
|
|
2690
|
+
* @response `404` `void` Not Found
|
|
2691
|
+
*/
|
|
2692
|
+
postRedisRecord: (data: FindRedisRecordRequest, axiosConfig?: AxiosRequestConfig) => Promise<FindRedisRecordResponse>;
|
|
2693
|
+
/**
|
|
2694
|
+
* No description
|
|
2695
|
+
*
|
|
2696
|
+
* @tags taskCount
|
|
2697
|
+
* @name DeleteRedisRecord
|
|
2698
|
+
* @summary 删除redis记录
|
|
2699
|
+
* @request DELETE:/auth-bpmn-query/task-count/redis-record
|
|
2700
|
+
* @response `200` `void` OK
|
|
2701
|
+
* @response `204` `void` No Content
|
|
2702
|
+
* @response `401` `void` Unauthorized
|
|
2703
|
+
* @response `403` `void` Forbidden
|
|
2704
|
+
*/
|
|
2705
|
+
deleteRedisRecord: (data: DeleteRedisRecordRequest, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2706
|
+
/**
|
|
2707
|
+
* No description
|
|
2708
|
+
*
|
|
2709
|
+
* @tags taskCount
|
|
2710
|
+
* @name RunningSingleTaskDepartment
|
|
2711
|
+
* @summary 根据部门代码获取处理中的单个任务数量
|
|
2712
|
+
* @request POST:/auth-bpmn-query/task-count/running-Single-task-department
|
|
2713
|
+
* @response `200` `(QueryDepartmentCountResponse)[]` OK
|
|
2714
|
+
* @response `201` `void` Created
|
|
2715
|
+
* @response `401` `void` Unauthorized
|
|
2716
|
+
* @response `403` `void` Forbidden
|
|
2717
|
+
* @response `404` `void` Not Found
|
|
2718
|
+
*/
|
|
2719
|
+
runningSingleTaskDepartment: (data: QuerySingleTaskCountByDeptRequest, axiosConfig?: AxiosRequestConfig) => Promise<QueryDepartmentCountResponse[]>;
|
|
2720
|
+
/**
|
|
2721
|
+
* No description
|
|
2722
|
+
*
|
|
2723
|
+
* @tags taskCount
|
|
2724
|
+
* @name RunningMultipleTaskCount
|
|
2725
|
+
* @summary 根据用户名批量获取处理中的多个任务数量
|
|
2726
|
+
* @request POST:/auth-bpmn-query/task-count/running-multiple-task-count
|
|
2727
|
+
* @response `200` `(QueryCountResponse)[]` OK
|
|
2728
|
+
* @response `201` `void` Created
|
|
2729
|
+
* @response `401` `void` Unauthorized
|
|
2730
|
+
* @response `403` `void` Forbidden
|
|
2731
|
+
* @response `404` `void` Not Found
|
|
2732
|
+
*/
|
|
2733
|
+
runningMultipleTaskCount: (data: QueryMultipleTaskCountRequest, axiosConfig?: AxiosRequestConfig) => Promise<QueryCountResponse[]>;
|
|
2734
|
+
/**
|
|
2735
|
+
* No description
|
|
2736
|
+
*
|
|
2737
|
+
* @tags taskCount
|
|
2738
|
+
* @name RunningMultipleTaskDepartment
|
|
2739
|
+
* @summary 根据部门代码获取处理中的多个任务数量
|
|
2740
|
+
* @request POST:/auth-bpmn-query/task-count/running-multiple-task-department
|
|
2741
|
+
* @response `200` `(QueryDepartmentCountResponse)[]` OK
|
|
2742
|
+
* @response `201` `void` Created
|
|
2743
|
+
* @response `401` `void` Unauthorized
|
|
2744
|
+
* @response `403` `void` Forbidden
|
|
2745
|
+
* @response `404` `void` Not Found
|
|
2746
|
+
*/
|
|
2747
|
+
runningMultipleTaskDepartment: (data: QueryMultipleTaskCountByDeptRequest, axiosConfig?: AxiosRequestConfig) => Promise<QueryDepartmentCountResponse[]>;
|
|
2748
|
+
/**
|
|
2749
|
+
* No description
|
|
2750
|
+
*
|
|
2751
|
+
* @tags taskCount
|
|
2752
|
+
* @name RunningSingleTaskCount
|
|
2753
|
+
* @summary 根据用户名批量获取处理中的单个任务数量
|
|
2754
|
+
* @request POST:/auth-bpmn-query/task-count/running-single-task-count
|
|
2755
|
+
* @response `200` `(QueryCountResponse)[]` OK
|
|
2756
|
+
* @response `201` `void` Created
|
|
2757
|
+
* @response `401` `void` Unauthorized
|
|
2758
|
+
* @response `403` `void` Forbidden
|
|
2759
|
+
* @response `404` `void` Not Found
|
|
2760
|
+
*/
|
|
2761
|
+
runningSingleTaskCount: (data: QuerySingleTaskCountRequest, axiosConfig?: AxiosRequestConfig) => Promise<QueryCountResponse[]>;
|
|
2762
|
+
/**
|
|
2763
|
+
* No description
|
|
2764
|
+
*
|
|
2765
|
+
* @tags taskCount
|
|
2766
|
+
* @name GetByUser
|
|
2767
|
+
* @summary 根据用户名获取redisKey
|
|
2768
|
+
* @request GET:/auth-bpmn-query/task-count/{user}
|
|
2769
|
+
* @response `200` `(string)[]` OK
|
|
2770
|
+
* @response `401` `void` Unauthorized
|
|
2771
|
+
* @response `403` `void` Forbidden
|
|
2772
|
+
* @response `404` `void` Not Found
|
|
2773
|
+
*/
|
|
2774
|
+
getByUser: (user: string, axiosConfig?: AxiosRequestConfig) => Promise<string[]>;
|
|
2775
|
+
/**
|
|
2776
|
+
* No description
|
|
2777
|
+
*
|
|
2778
|
+
* @tags taskCount
|
|
2779
|
+
* @name PutByUser
|
|
2780
|
+
* @summary 重新整理用户处理中的流程和任务的redisRecord
|
|
2781
|
+
* @request PUT:/auth-bpmn-query/task-count/{user}
|
|
2782
|
+
* @response `200` `void` OK
|
|
2783
|
+
* @response `201` `void` Created
|
|
2784
|
+
* @response `401` `void` Unauthorized
|
|
2785
|
+
* @response `403` `void` Forbidden
|
|
2786
|
+
* @response `404` `void` Not Found
|
|
2787
|
+
*/
|
|
2788
|
+
putByUser: (user: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2789
|
+
};
|
|
2790
|
+
task: {
|
|
2791
|
+
/**
|
|
2792
|
+
* @description 所需权限:bpmn:process:basic
|
|
2793
|
+
*
|
|
2794
|
+
* @tags task
|
|
2795
|
+
* @name Task
|
|
2796
|
+
* @summary 流程任务节点分页查询
|
|
2797
|
+
* @request GET:/auth-bpmn-query/task
|
|
2798
|
+
* @response `200` `PageResultProcessTaskWithProcessInfo` OK
|
|
2799
|
+
* @response `401` `void` Unauthorized
|
|
2800
|
+
* @response `403` `void` Forbidden
|
|
2801
|
+
* @response `404` `void` Not Found
|
|
2802
|
+
*/
|
|
2803
|
+
task: (query: TaskParams, axiosConfig?: AxiosRequestConfig) => Promise<PageResultProcessTaskWithProcessInfo>;
|
|
2804
|
+
/**
|
|
2805
|
+
* @description 所需权限:bpmn:process:basic
|
|
2806
|
+
*
|
|
2807
|
+
* @tags task
|
|
2808
|
+
* @name AssigneeOrCandidate
|
|
2809
|
+
* @summary 查询待处理的流程任务节点。不支持分页
|
|
2810
|
+
* @request GET:/auth-bpmn-query/task/assignee-or-candidate
|
|
2811
|
+
* @response `200` `(ProcessTaskWithProcessInfo)[]` OK
|
|
2812
|
+
* @response `401` `void` Unauthorized
|
|
2813
|
+
* @response `403` `void` Forbidden
|
|
2814
|
+
* @response `404` `void` Not Found
|
|
2815
|
+
*/
|
|
2816
|
+
assigneeOrCandidate: (query: AssigneeOrCandidateParams, axiosConfig?: AxiosRequestConfig) => Promise<ProcessTaskWithProcessInfo[]>;
|
|
2817
|
+
/**
|
|
2818
|
+
* @description 所需权限:bpmn:process:basic
|
|
2819
|
+
*
|
|
2820
|
+
* @tags task
|
|
2821
|
+
* @name AssigneeOrCandidateCount
|
|
2822
|
+
* @summary 查询待处理的流程任务节点数量
|
|
2823
|
+
* @request GET:/auth-bpmn-query/task/assignee-or-candidate/count
|
|
2824
|
+
* @response `200` `number` OK
|
|
2825
|
+
* @response `401` `void` Unauthorized
|
|
2826
|
+
* @response `403` `void` Forbidden
|
|
2827
|
+
* @response `404` `void` Not Found
|
|
2828
|
+
*/
|
|
2829
|
+
assigneeOrCandidateCount: (query: AssigneeOrCandidateCountParams, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2830
|
+
/**
|
|
2831
|
+
* @description 所需权限:bpmn:process:basic
|
|
2832
|
+
*
|
|
2833
|
+
* @tags task
|
|
2834
|
+
* @name Count
|
|
2835
|
+
* @summary 流程任务节点数量查询
|
|
2836
|
+
* @request GET:/auth-bpmn-query/task/count
|
|
2837
|
+
* @response `200` `number` OK
|
|
2838
|
+
* @response `401` `void` Unauthorized
|
|
2839
|
+
* @response `403` `void` Forbidden
|
|
2840
|
+
* @response `404` `void` Not Found
|
|
2841
|
+
*/
|
|
2842
|
+
count: (query: CountParams10, axiosConfig?: AxiosRequestConfig) => Promise<number>;
|
|
2843
|
+
/**
|
|
2844
|
+
* No description
|
|
2845
|
+
*
|
|
2846
|
+
* @tags task
|
|
2847
|
+
* @name DetailById
|
|
2848
|
+
* @summary 获取流程任务节点详情
|
|
2849
|
+
* @request GET:/auth-bpmn-query/task/detail/{id}
|
|
2850
|
+
* @response `200` `ProcessTaskWithProcessInfo` OK
|
|
2851
|
+
* @response `401` `void` Unauthorized
|
|
2852
|
+
* @response `403` `void` Forbidden
|
|
2853
|
+
* @response `404` `void` Not Found
|
|
2854
|
+
*/
|
|
2855
|
+
detailById: ({ id, ...query }: DetailByIdParams5, axiosConfig?: AxiosRequestConfig) => Promise<ProcessTaskWithProcessInfo>;
|
|
2856
|
+
/**
|
|
2857
|
+
* No description
|
|
2858
|
+
*
|
|
2859
|
+
* @tags task
|
|
2860
|
+
* @name PutDetailReadById
|
|
2861
|
+
* @summary 标记任务节点为已读
|
|
2862
|
+
* @request PUT:/auth-bpmn-query/task/detail/{id}/read
|
|
2863
|
+
* @response `200` `void` OK
|
|
2864
|
+
* @response `201` `void` Created
|
|
2865
|
+
* @response `401` `void` Unauthorized
|
|
2866
|
+
* @response `403` `void` Forbidden
|
|
2867
|
+
* @response `404` `void` Not Found
|
|
2868
|
+
*/
|
|
2869
|
+
putDetailReadById: (id: string, axiosConfig?: AxiosRequestConfig) => Promise<void>;
|
|
2870
|
+
};
|
|
2871
|
+
}
|
|
2872
|
+
export declare const authBpmnQueryApi: Api;
|
|
2873
|
+
export {};
|