web-core-tcm 0.0.38 → 0.0.40

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.
Files changed (18) hide show
  1. package/dist/src/api/authorization/alova/globals.d.ts +250 -352
  2. package/dist/src/api/authorization/alova/implement/authorization.d.ts +1 -1
  3. package/dist/src/api/authorization/alova/index.d.ts +1 -0
  4. package/dist/src/api/check/alova/globals.d.ts +1097 -1205
  5. package/dist/src/api/check/alova/index.d.ts +1 -0
  6. package/dist/src/api/doctor/alova/globals.d.ts +419 -523
  7. package/dist/src/api/doctor/alova/index.d.ts +1 -0
  8. package/dist/src/api/oauth/alova/globals.d.ts +312 -412
  9. package/dist/src/api/oauth/alova/index.d.ts +1 -0
  10. package/dist/src/api/outpatient/alova/globals.d.ts +543 -643
  11. package/dist/src/api/outpatient/alova/index.d.ts +1 -0
  12. package/dist/src/api/patient/alova/globals.d.ts +1480 -1636
  13. package/dist/src/api/patient/alova/index.d.ts +1 -0
  14. package/dist/src/api/prescription/alova/globals.d.ts +812 -926
  15. package/dist/src/api/prescription/alova/index.d.ts +1 -0
  16. package/dist/src/api/scientist/alova/globals.d.ts +315 -415
  17. package/dist/src/api/scientist/alova/index.d.ts +1 -1
  18. package/package.json +1 -1
package/dist/src/api/outpatient/alova/globals.d.ts CHANGED
@@ -3,666 +3,566 @@ import { $$userConfigMap, alovaInstance } from './index';
3
3
  import { default as apiDefinitions } from './apiDefinitions';
4
4
  type CollapsedAlova = typeof alovaInstance;
5
5
  type UserMethodConfigMap = typeof $$userConfigMap;
6
-
7
- type Alova2MethodConfig<Responded> =
8
- CollapsedAlova extends Alova<
9
- AlovaGenerics<
10
- any,
11
- any,
12
- infer RequestConfig,
13
- infer Response,
14
- infer ResponseHeader,
15
- infer L1Cache,
16
- infer L2Cache,
17
- infer SE
18
- >
19
- >
20
- ? Omit<
21
- AlovaMethodCreateConfig<
22
- AlovaGenerics<
23
- Responded,
24
- any,
25
- RequestConfig,
26
- Response,
27
- ResponseHeader,
28
- L1Cache,
29
- L2Cache,
30
- SE
31
- >,
32
- any,
33
- Responded
34
- >,
35
- 'params'
36
- >
37
- : never;
38
-
39
- // Extract the return type of transform function that define in $$userConfigMap, if it not exists, use the default type.
40
- type ExtractUserDefinedTransformed<
41
- DefinitionKey extends keyof typeof apiDefinitions,
42
- Default,
43
- > = DefinitionKey extends keyof UserMethodConfigMap
44
- ? UserMethodConfigMap[DefinitionKey]['transform'] extends (...args: any[]) => any
45
- ? Awaited<ReturnType<UserMethodConfigMap[DefinitionKey]['transform']>>
46
- : Default
47
- : Default;
48
- type Alova2Method<
49
- Responded,
50
- DefinitionKey extends keyof typeof apiDefinitions,
51
- CurrentConfig extends Alova2MethodConfig<any>,
52
- > =
53
- CollapsedAlova extends Alova<
54
- AlovaGenerics<
55
- any,
56
- any,
57
- infer RequestConfig,
58
- infer Response,
59
- infer ResponseHeader,
60
- infer L1Cache,
61
- infer L2Cache,
62
- infer SE
63
- >
64
- >
65
- ? Method<
66
- AlovaGenerics<
67
- CurrentConfig extends undefined
68
- ? ExtractUserDefinedTransformed<DefinitionKey, Responded>
69
- : CurrentConfig['transform'] extends (...args: any[]) => any
70
- ? Awaited<ReturnType<CurrentConfig['transform']>>
71
- : ExtractUserDefinedTransformed<DefinitionKey, Responded>,
72
- any,
73
- RequestConfig,
74
- Response,
75
- ResponseHeader,
76
- L1Cache,
77
- L2Cache,
78
- SE
79
- >
80
- >
81
- : never;
82
-
6
+ type Alova2MethodConfig<Responded> = CollapsedAlova extends Alova<AlovaGenerics<any, any, infer RequestConfig, infer Response, infer ResponseHeader, infer L1Cache, infer L2Cache, infer SE>> ? Omit<AlovaMethodCreateConfig<AlovaGenerics<Responded, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache, SE>, any, Responded>, 'params'> : never;
7
+ type ExtractUserDefinedTransformed<DefinitionKey extends keyof typeof apiDefinitions, Default> = DefinitionKey extends keyof UserMethodConfigMap ? UserMethodConfigMap[DefinitionKey]['transform'] extends (...args: any[]) => any ? Awaited<ReturnType<UserMethodConfigMap[DefinitionKey]['transform']>> : Default : Default;
8
+ type Alova2Method<Responded, DefinitionKey extends keyof typeof apiDefinitions, CurrentConfig extends Alova2MethodConfig<any>> = CollapsedAlova extends Alova<AlovaGenerics<any, any, infer RequestConfig, infer Response, infer ResponseHeader, infer L1Cache, infer L2Cache, infer SE>> ? Method<AlovaGenerics<CurrentConfig extends undefined ? ExtractUserDefinedTransformed<DefinitionKey, Responded> : CurrentConfig['transform'] extends (...args: any[]) => any ? Awaited<ReturnType<CurrentConfig['transform']>> : ExtractUserDefinedTransformed<DefinitionKey, Responded>, any, RequestConfig, Response, ResponseHeader, L1Cache, L2Cache, SE>> : never;
83
9
  export interface AnnotationState {
84
- value?: string;
85
- actor?: string;
86
- timestamp?: string;
10
+ value?: string;
11
+ actor?: string;
12
+ timestamp?: string;
87
13
  }
88
14
  export interface TagState {
89
- key?: string;
90
- annotationsState?: AnnotationState[];
15
+ key?: string;
16
+ annotationsState?: AnnotationState[];
91
17
  }
92
18
  export interface PatientState {
93
- id?: string;
94
- doctorId?: string;
95
- name?: string;
96
- createdTimestamp?: string;
97
- updatedTimestamp?: string;
98
- identity?: string;
99
- gender?: string;
100
- phoneNumber?: string;
101
- birthdate?: string;
102
- remarks?: string[];
103
- tagsState?: TagState[];
104
- mainSymptom?: string;
19
+ id?: string;
20
+ doctorId?: string;
21
+ name?: string;
22
+ createdTimestamp?: string;
23
+ updatedTimestamp?: string;
24
+ identity?: string;
25
+ gender?: string;
26
+ phoneNumber?: string;
27
+ birthdate?: string;
28
+ remarks?: string[];
29
+ tagsState?: TagState[];
30
+ mainSymptom?: string;
105
31
  }
106
32
  export interface DoctorState {
107
- id?: string;
108
- name?: string;
109
- createdTimestamp?: string;
110
- updatedTimestamp?: string;
111
- gender?: string;
112
- identityNumber?: string;
113
- phoneNumber?: string;
114
- birthdate?: string;
33
+ id?: string;
34
+ name?: string;
35
+ createdTimestamp?: string;
36
+ updatedTimestamp?: string;
37
+ gender?: string;
38
+ identityNumber?: string;
39
+ phoneNumber?: string;
40
+ birthdate?: string;
115
41
  }
116
42
  export interface QueuerState {
117
- id?: string;
118
- patientState?: PatientState;
119
- doctorState?: DoctorState;
120
- createdTimestamp?: string;
121
- updatedTimestamp?: string;
122
- status?: number;
43
+ id?: string;
44
+ patientState?: PatientState;
45
+ doctorState?: DoctorState;
46
+ createdTimestamp?: string;
47
+ updatedTimestamp?: string;
48
+ status?: number;
123
49
  }
124
50
  export interface DateDistribute {
125
- date?: string;
126
- count?: number;
51
+ date?: string;
52
+ count?: number;
127
53
  }
128
54
  export interface SortObject {
129
- empty?: boolean;
130
- sorted?: boolean;
131
- unsorted?: boolean;
55
+ empty?: boolean;
56
+ sorted?: boolean;
57
+ unsorted?: boolean;
132
58
  }
133
59
  export interface PageableObject {
134
- offset?: number;
135
- sort?: SortObject;
136
- pageSize?: number;
137
- paged?: boolean;
138
- pageNumber?: number;
139
- unpaged?: boolean;
60
+ offset?: number;
61
+ sort?: SortObject;
62
+ pageSize?: number;
63
+ paged?: boolean;
64
+ pageNumber?: number;
65
+ unpaged?: boolean;
140
66
  }
141
67
  export interface PageQueuerState {
142
- totalPages?: number;
143
- totalElements?: number;
144
- size?: number;
145
- content?: QueuerState[];
146
- number?: number;
147
- sort?: SortObject;
148
- first?: boolean;
149
- last?: boolean;
150
- numberOfElements?: number;
151
- pageable?: PageableObject;
152
- empty?: boolean;
68
+ totalPages?: number;
69
+ totalElements?: number;
70
+ size?: number;
71
+ content?: QueuerState[];
72
+ number?: number;
73
+ sort?: SortObject;
74
+ first?: boolean;
75
+ last?: boolean;
76
+ numberOfElements?: number;
77
+ pageable?: PageableObject;
78
+ empty?: boolean;
153
79
  }
154
80
  declare global {
155
- interface outpatientApi {
156
- queuerRestful: {
157
- /**
158
- * ---
159
- *
160
- * [GET]
161
- *
162
- * **path:** /门诊/服务/排队/{id}
163
- *
164
- * ---
165
- *
166
- * **Path Parameters**
167
- * ```ts
168
- * type PathParameters = {
169
- * id: string
170
- * }
171
- * ```
172
- *
173
- * ---
174
- *
175
- * **Response**
176
- * ```ts
177
- * type Response = {
178
- * id?: string
179
- * patientState?: {
180
- * id?: string
181
- * doctorId?: string
182
- * name?: string
183
- * createdTimestamp?: string
184
- * updatedTimestamp?: string
185
- * identity?: string
186
- * gender?: string
187
- * phoneNumber?: string
188
- * birthdate?: string
189
- * // [items] start
190
- * // [items] end
191
- * remarks?: string[]
192
- * // [items] start
193
- * // [items] end
194
- * tagsState?: Array<{
195
- * key?: string
196
- * // [items] start
197
- * // [items] end
198
- * annotationsState?: Array<{
199
- * value?: string
200
- * actor?: string
201
- * timestamp?: string
202
- * }>
203
- * }>
204
- * mainSymptom?: string
205
- * }
206
- * doctorState?: {
207
- * id?: string
208
- * name?: string
209
- * createdTimestamp?: string
210
- * updatedTimestamp?: string
211
- * gender?: string
212
- * identityNumber?: string
213
- * phoneNumber?: string
214
- * birthdate?: string
215
- * }
216
- * createdTimestamp?: string
217
- * updatedTimestamp?: string
218
- * status?: number
219
- * }
220
- * ```
221
- */
222
- getQueuerState<
223
- Config extends Alova2MethodConfig<QueuerState> & {
224
- pathParams: {
225
- id: string;
226
- };
227
- },
228
- >(
229
- config: Config,
230
- ): Alova2Method<QueuerState, 'queuerRestful.getQueuerState', Config>;
231
- /**
232
- * ---
233
- *
234
- * [PUT]
235
- *
236
- * **path:** /门诊/服务/排队/{id}
237
- *
238
- * ---
239
- *
240
- * **Path Parameters**
241
- * ```ts
242
- * type PathParameters = {
243
- * id: string
244
- * }
245
- * ```
246
- *
247
- * ---
248
- *
249
- * **RequestBody**
250
- * ```ts
251
- * type RequestBody = {
252
- * id?: string
253
- * patientState?: {
254
- * id?: string
255
- * doctorId?: string
256
- * name?: string
257
- * createdTimestamp?: string
258
- * updatedTimestamp?: string
259
- * identity?: string
260
- * gender?: string
261
- * phoneNumber?: string
262
- * birthdate?: string
263
- * // [items] start
264
- * // [items] end
265
- * remarks?: string[]
266
- * // [items] start
267
- * // [items] end
268
- * tagsState?: Array<{
269
- * key?: string
270
- * // [items] start
271
- * // [items] end
272
- * annotationsState?: Array<{
273
- * value?: string
274
- * actor?: string
275
- * timestamp?: string
276
- * }>
277
- * }>
278
- * mainSymptom?: string
279
- * }
280
- * doctorState?: {
281
- * id?: string
282
- * name?: string
283
- * createdTimestamp?: string
284
- * updatedTimestamp?: string
285
- * gender?: string
286
- * identityNumber?: string
287
- * phoneNumber?: string
288
- * birthdate?: string
289
- * }
290
- * createdTimestamp?: string
291
- * updatedTimestamp?: string
292
- * status?: number
293
- * }
294
- * ```
295
- *
296
- * ---
297
- *
298
- * **Response**
299
- * ```ts
300
- * type Response = {
301
- * id?: string
302
- * patientState?: {
303
- * id?: string
304
- * doctorId?: string
305
- * name?: string
306
- * createdTimestamp?: string
307
- * updatedTimestamp?: string
308
- * identity?: string
309
- * gender?: string
310
- * phoneNumber?: string
311
- * birthdate?: string
312
- * // [items] start
313
- * // [items] end
314
- * remarks?: string[]
315
- * // [items] start
316
- * // [items] end
317
- * tagsState?: Array<{
318
- * key?: string
319
- * // [items] start
320
- * // [items] end
321
- * annotationsState?: Array<{
322
- * value?: string
323
- * actor?: string
324
- * timestamp?: string
325
- * }>
326
- * }>
327
- * mainSymptom?: string
328
- * }
329
- * doctorState?: {
330
- * id?: string
331
- * name?: string
332
- * createdTimestamp?: string
333
- * updatedTimestamp?: string
334
- * gender?: string
335
- * identityNumber?: string
336
- * phoneNumber?: string
337
- * birthdate?: string
338
- * }
339
- * createdTimestamp?: string
340
- * updatedTimestamp?: string
341
- * status?: number
342
- * }
343
- * ```
344
- */
345
- putQueuerState<
346
- Config extends Alova2MethodConfig<QueuerState> & {
347
- pathParams: {
348
- id: string;
349
- };
350
- data: QueuerState;
351
- },
352
- >(
353
- config: Config,
354
- ): Alova2Method<QueuerState, 'queuerRestful.putQueuerState', Config>;
355
- /**
356
- * ---
357
- *
358
- * [DELETE]
359
- *
360
- * **path:** /门诊/服务/排队/{id}
361
- *
362
- * ---
363
- *
364
- * **Path Parameters**
365
- * ```ts
366
- * type PathParameters = {
367
- * id: string
368
- * }
369
- * ```
370
- *
371
- * ---
372
- *
373
- * **Response**
374
- * ```ts
375
- * type Response = null
376
- * ```
377
- */
378
- deleteQueuerState<
379
- Config extends Alova2MethodConfig<null> & {
380
- pathParams: {
381
- id: string;
382
- };
383
- },
384
- >(
385
- config: Config,
386
- ): Alova2Method<null, 'queuerRestful.deleteQueuerState', Config>;
387
- /**
388
- * ---
389
- *
390
- * [GET]
391
- *
392
- * **path:** /门诊/服务/排队
393
- *
394
- * ---
395
- *
396
- * **Query Parameters**
397
- * ```ts
398
- * type QueryParameters = {
399
- * doctorId?: string
400
- * patientId?: string
401
- * page: number
402
- * pageSize: number
403
- * }
404
- * ```
405
- *
406
- * ---
407
- *
408
- * **Response**
409
- * ```ts
410
- * type Response = {
411
- * totalPages?: number
412
- * totalElements?: number
413
- * size?: number
414
- * // [items] start
415
- * // [items] end
416
- * content?: Array<{
417
- * id?: string
418
- * patientState?: {
419
- * id?: string
420
- * doctorId?: string
421
- * name?: string
422
- * createdTimestamp?: string
423
- * updatedTimestamp?: string
424
- * identity?: string
425
- * gender?: string
426
- * phoneNumber?: string
427
- * birthdate?: string
428
- * // [items] start
429
- * // [items] end
430
- * remarks?: string[]
431
- * // [items] start
432
- * // [items] end
433
- * tagsState?: Array<{
434
- * key?: string
435
- * // [items] start
436
- * // [items] end
437
- * annotationsState?: Array<{
438
- * value?: string
439
- * actor?: string
440
- * timestamp?: string
441
- * }>
442
- * }>
443
- * mainSymptom?: string
444
- * }
445
- * doctorState?: {
446
- * id?: string
447
- * name?: string
448
- * createdTimestamp?: string
449
- * updatedTimestamp?: string
450
- * gender?: string
451
- * identityNumber?: string
452
- * phoneNumber?: string
453
- * birthdate?: string
454
- * }
455
- * createdTimestamp?: string
456
- * updatedTimestamp?: string
457
- * status?: number
458
- * }>
459
- * number?: number
460
- * sort?: {
461
- * empty?: boolean
462
- * sorted?: boolean
463
- * unsorted?: boolean
464
- * }
465
- * first?: boolean
466
- * last?: boolean
467
- * numberOfElements?: number
468
- * pageable?: {
469
- * offset?: number
470
- * sort?: {
471
- * empty?: boolean
472
- * sorted?: boolean
473
- * unsorted?: boolean
474
- * }
475
- * pageSize?: number
476
- * paged?: boolean
477
- * pageNumber?: number
478
- * unpaged?: boolean
479
- * }
480
- * empty?: boolean
481
- * }
482
- * ```
483
- */
484
- queryQueuerState<
485
- Config extends Alova2MethodConfig<PageQueuerState> & {
486
- params: {
487
- doctorId?: string;
488
- patientId?: string;
489
- page: number;
490
- pageSize: number;
491
- };
492
- },
493
- >(
494
- config: Config,
495
- ): Alova2Method<PageQueuerState, 'queuerRestful.queryQueuerState', Config>;
496
- /**
497
- * ---
498
- *
499
- * [POST]
500
- *
501
- * **path:** /门诊/服务/排队
502
- *
503
- * ---
504
- *
505
- * **RequestBody**
506
- * ```ts
507
- * type RequestBody = {
508
- * id?: string
509
- * patientState?: {
510
- * id?: string
511
- * doctorId?: string
512
- * name?: string
513
- * createdTimestamp?: string
514
- * updatedTimestamp?: string
515
- * identity?: string
516
- * gender?: string
517
- * phoneNumber?: string
518
- * birthdate?: string
519
- * // [items] start
520
- * // [items] end
521
- * remarks?: string[]
522
- * // [items] start
523
- * // [items] end
524
- * tagsState?: Array<{
525
- * key?: string
526
- * // [items] start
527
- * // [items] end
528
- * annotationsState?: Array<{
529
- * value?: string
530
- * actor?: string
531
- * timestamp?: string
532
- * }>
533
- * }>
534
- * mainSymptom?: string
535
- * }
536
- * doctorState?: {
537
- * id?: string
538
- * name?: string
539
- * createdTimestamp?: string
540
- * updatedTimestamp?: string
541
- * gender?: string
542
- * identityNumber?: string
543
- * phoneNumber?: string
544
- * birthdate?: string
545
- * }
546
- * createdTimestamp?: string
547
- * updatedTimestamp?: string
548
- * status?: number
549
- * }
550
- * ```
551
- *
552
- * ---
553
- *
554
- * **Response**
555
- * ```ts
556
- * type Response = {
557
- * id?: string
558
- * patientState?: {
559
- * id?: string
560
- * doctorId?: string
561
- * name?: string
562
- * createdTimestamp?: string
563
- * updatedTimestamp?: string
564
- * identity?: string
565
- * gender?: string
566
- * phoneNumber?: string
567
- * birthdate?: string
568
- * // [items] start
569
- * // [items] end
570
- * remarks?: string[]
571
- * // [items] start
572
- * // [items] end
573
- * tagsState?: Array<{
574
- * key?: string
575
- * // [items] start
576
- * // [items] end
577
- * annotationsState?: Array<{
578
- * value?: string
579
- * actor?: string
580
- * timestamp?: string
581
- * }>
582
- * }>
583
- * mainSymptom?: string
584
- * }
585
- * doctorState?: {
586
- * id?: string
587
- * name?: string
588
- * createdTimestamp?: string
589
- * updatedTimestamp?: string
590
- * gender?: string
591
- * identityNumber?: string
592
- * phoneNumber?: string
593
- * birthdate?: string
594
- * }
595
- * createdTimestamp?: string
596
- * updatedTimestamp?: string
597
- * status?: number
598
- * }
599
- * ```
600
- */
601
- postQueuerState<
602
- Config extends Alova2MethodConfig<QueuerState> & {
603
- data: QueuerState;
604
- },
605
- >(
606
- config: Config,
607
- ): Alova2Method<QueuerState, 'queuerRestful.postQueuerState', Config>;
608
- };
609
- metricRestful: {
610
- /**
611
- * ---
612
- *
613
- * [GET]
614
- *
615
- * **path:** /门诊/服务/统计/排队/日期
616
- *
617
- * ---
618
- *
619
- * **Response**
620
- * ```ts
621
- * type Response = Array<{
622
- * date?: string
623
- * count?: number
624
- * }>
625
- * ```
626
- */
627
- datesOfQueuerState<Config extends Alova2MethodConfig<DateDistribute[]>>(
628
- config?: Config,
629
- ): Alova2Method<DateDistribute[], 'metricRestful.datesOfQueuerState', Config>;
630
- /**
631
- * ---
632
- *
633
- * [GET]
634
- *
635
- * **path:** /门诊/服务/统计/排队/总数
636
- *
637
- * ---
638
- *
639
- * **Response**
640
- * ```ts
641
- * type Response = number
642
- * ```
643
- */
644
- totalOfQueuerState<Config extends Alova2MethodConfig<number>>(
645
- config?: Config,
646
- ): Alova2Method<number, 'metricRestful.totalOfQueuerState', Config>;
647
- /**
648
- * ---
649
- *
650
- * [GET]
651
- *
652
- * **path:** /门诊/服务/统计/排队/今日
653
- *
654
- * ---
655
- *
656
- * **Response**
657
- * ```ts
658
- * type Response = number
659
- * ```
660
- */
661
- totalOfQueuerTodayState<Config extends Alova2MethodConfig<number>>(
662
- config?: Config,
663
- ): Alova2Method<number, 'metricRestful.totalOfQueuerTodayState', Config>;
664
- };
665
- }
666
-
667
- var outpatientApi: outpatientApi;
81
+ interface outpatientApi {
82
+ queuerRestful: {
83
+ /**
84
+ * ---
85
+ *
86
+ * [GET]
87
+ *
88
+ * **path:** /门诊/服务/排队/{id}
89
+ *
90
+ * ---
91
+ *
92
+ * **Path Parameters**
93
+ * ```ts
94
+ * type PathParameters = {
95
+ * id: string
96
+ * }
97
+ * ```
98
+ *
99
+ * ---
100
+ *
101
+ * **Response**
102
+ * ```ts
103
+ * type Response = {
104
+ * id?: string
105
+ * patientState?: {
106
+ * id?: string
107
+ * doctorId?: string
108
+ * name?: string
109
+ * createdTimestamp?: string
110
+ * updatedTimestamp?: string
111
+ * identity?: string
112
+ * gender?: string
113
+ * phoneNumber?: string
114
+ * birthdate?: string
115
+ * // [items] start
116
+ * // [items] end
117
+ * remarks?: string[]
118
+ * // [items] start
119
+ * // [items] end
120
+ * tagsState?: Array<{
121
+ * key?: string
122
+ * // [items] start
123
+ * // [items] end
124
+ * annotationsState?: Array<{
125
+ * value?: string
126
+ * actor?: string
127
+ * timestamp?: string
128
+ * }>
129
+ * }>
130
+ * mainSymptom?: string
131
+ * }
132
+ * doctorState?: {
133
+ * id?: string
134
+ * name?: string
135
+ * createdTimestamp?: string
136
+ * updatedTimestamp?: string
137
+ * gender?: string
138
+ * identityNumber?: string
139
+ * phoneNumber?: string
140
+ * birthdate?: string
141
+ * }
142
+ * createdTimestamp?: string
143
+ * updatedTimestamp?: string
144
+ * status?: number
145
+ * }
146
+ * ```
147
+ */
148
+ getQueuerState<Config extends Alova2MethodConfig<QueuerState> & {
149
+ pathParams: {
150
+ id: string;
151
+ };
152
+ }>(config: Config): Alova2Method<QueuerState, 'queuerRestful.getQueuerState', Config>;
153
+ /**
154
+ * ---
155
+ *
156
+ * [PUT]
157
+ *
158
+ * **path:** /门诊/服务/排队/{id}
159
+ *
160
+ * ---
161
+ *
162
+ * **Path Parameters**
163
+ * ```ts
164
+ * type PathParameters = {
165
+ * id: string
166
+ * }
167
+ * ```
168
+ *
169
+ * ---
170
+ *
171
+ * **RequestBody**
172
+ * ```ts
173
+ * type RequestBody = {
174
+ * id?: string
175
+ * patientState?: {
176
+ * id?: string
177
+ * doctorId?: string
178
+ * name?: string
179
+ * createdTimestamp?: string
180
+ * updatedTimestamp?: string
181
+ * identity?: string
182
+ * gender?: string
183
+ * phoneNumber?: string
184
+ * birthdate?: string
185
+ * // [items] start
186
+ * // [items] end
187
+ * remarks?: string[]
188
+ * // [items] start
189
+ * // [items] end
190
+ * tagsState?: Array<{
191
+ * key?: string
192
+ * // [items] start
193
+ * // [items] end
194
+ * annotationsState?: Array<{
195
+ * value?: string
196
+ * actor?: string
197
+ * timestamp?: string
198
+ * }>
199
+ * }>
200
+ * mainSymptom?: string
201
+ * }
202
+ * doctorState?: {
203
+ * id?: string
204
+ * name?: string
205
+ * createdTimestamp?: string
206
+ * updatedTimestamp?: string
207
+ * gender?: string
208
+ * identityNumber?: string
209
+ * phoneNumber?: string
210
+ * birthdate?: string
211
+ * }
212
+ * createdTimestamp?: string
213
+ * updatedTimestamp?: string
214
+ * status?: number
215
+ * }
216
+ * ```
217
+ *
218
+ * ---
219
+ *
220
+ * **Response**
221
+ * ```ts
222
+ * type Response = {
223
+ * id?: string
224
+ * patientState?: {
225
+ * id?: string
226
+ * doctorId?: string
227
+ * name?: string
228
+ * createdTimestamp?: string
229
+ * updatedTimestamp?: string
230
+ * identity?: string
231
+ * gender?: string
232
+ * phoneNumber?: string
233
+ * birthdate?: string
234
+ * // [items] start
235
+ * // [items] end
236
+ * remarks?: string[]
237
+ * // [items] start
238
+ * // [items] end
239
+ * tagsState?: Array<{
240
+ * key?: string
241
+ * // [items] start
242
+ * // [items] end
243
+ * annotationsState?: Array<{
244
+ * value?: string
245
+ * actor?: string
246
+ * timestamp?: string
247
+ * }>
248
+ * }>
249
+ * mainSymptom?: string
250
+ * }
251
+ * doctorState?: {
252
+ * id?: string
253
+ * name?: string
254
+ * createdTimestamp?: string
255
+ * updatedTimestamp?: string
256
+ * gender?: string
257
+ * identityNumber?: string
258
+ * phoneNumber?: string
259
+ * birthdate?: string
260
+ * }
261
+ * createdTimestamp?: string
262
+ * updatedTimestamp?: string
263
+ * status?: number
264
+ * }
265
+ * ```
266
+ */
267
+ putQueuerState<Config extends Alova2MethodConfig<QueuerState> & {
268
+ pathParams: {
269
+ id: string;
270
+ };
271
+ data: QueuerState;
272
+ }>(config: Config): Alova2Method<QueuerState, 'queuerRestful.putQueuerState', Config>;
273
+ /**
274
+ * ---
275
+ *
276
+ * [DELETE]
277
+ *
278
+ * **path:** /门诊/服务/排队/{id}
279
+ *
280
+ * ---
281
+ *
282
+ * **Path Parameters**
283
+ * ```ts
284
+ * type PathParameters = {
285
+ * id: string
286
+ * }
287
+ * ```
288
+ *
289
+ * ---
290
+ *
291
+ * **Response**
292
+ * ```ts
293
+ * type Response = null
294
+ * ```
295
+ */
296
+ deleteQueuerState<Config extends Alova2MethodConfig<null> & {
297
+ pathParams: {
298
+ id: string;
299
+ };
300
+ }>(config: Config): Alova2Method<null, 'queuerRestful.deleteQueuerState', Config>;
301
+ /**
302
+ * ---
303
+ *
304
+ * [GET]
305
+ *
306
+ * **path:** /门诊/服务/排队
307
+ *
308
+ * ---
309
+ *
310
+ * **Query Parameters**
311
+ * ```ts
312
+ * type QueryParameters = {
313
+ * doctorId?: string
314
+ * patientId?: string
315
+ * page: number
316
+ * pageSize: number
317
+ * }
318
+ * ```
319
+ *
320
+ * ---
321
+ *
322
+ * **Response**
323
+ * ```ts
324
+ * type Response = {
325
+ * totalPages?: number
326
+ * totalElements?: number
327
+ * size?: number
328
+ * // [items] start
329
+ * // [items] end
330
+ * content?: Array<{
331
+ * id?: string
332
+ * patientState?: {
333
+ * id?: string
334
+ * doctorId?: string
335
+ * name?: string
336
+ * createdTimestamp?: string
337
+ * updatedTimestamp?: string
338
+ * identity?: string
339
+ * gender?: string
340
+ * phoneNumber?: string
341
+ * birthdate?: string
342
+ * // [items] start
343
+ * // [items] end
344
+ * remarks?: string[]
345
+ * // [items] start
346
+ * // [items] end
347
+ * tagsState?: Array<{
348
+ * key?: string
349
+ * // [items] start
350
+ * // [items] end
351
+ * annotationsState?: Array<{
352
+ * value?: string
353
+ * actor?: string
354
+ * timestamp?: string
355
+ * }>
356
+ * }>
357
+ * mainSymptom?: string
358
+ * }
359
+ * doctorState?: {
360
+ * id?: string
361
+ * name?: string
362
+ * createdTimestamp?: string
363
+ * updatedTimestamp?: string
364
+ * gender?: string
365
+ * identityNumber?: string
366
+ * phoneNumber?: string
367
+ * birthdate?: string
368
+ * }
369
+ * createdTimestamp?: string
370
+ * updatedTimestamp?: string
371
+ * status?: number
372
+ * }>
373
+ * number?: number
374
+ * sort?: {
375
+ * empty?: boolean
376
+ * sorted?: boolean
377
+ * unsorted?: boolean
378
+ * }
379
+ * first?: boolean
380
+ * last?: boolean
381
+ * numberOfElements?: number
382
+ * pageable?: {
383
+ * offset?: number
384
+ * sort?: {
385
+ * empty?: boolean
386
+ * sorted?: boolean
387
+ * unsorted?: boolean
388
+ * }
389
+ * pageSize?: number
390
+ * paged?: boolean
391
+ * pageNumber?: number
392
+ * unpaged?: boolean
393
+ * }
394
+ * empty?: boolean
395
+ * }
396
+ * ```
397
+ */
398
+ queryQueuerState<Config extends Alova2MethodConfig<PageQueuerState> & {
399
+ params: {
400
+ doctorId?: string;
401
+ patientId?: string;
402
+ page: number;
403
+ pageSize: number;
404
+ };
405
+ }>(config: Config): Alova2Method<PageQueuerState, 'queuerRestful.queryQueuerState', Config>;
406
+ /**
407
+ * ---
408
+ *
409
+ * [POST]
410
+ *
411
+ * **path:** /门诊/服务/排队
412
+ *
413
+ * ---
414
+ *
415
+ * **RequestBody**
416
+ * ```ts
417
+ * type RequestBody = {
418
+ * id?: string
419
+ * patientState?: {
420
+ * id?: string
421
+ * doctorId?: string
422
+ * name?: string
423
+ * createdTimestamp?: string
424
+ * updatedTimestamp?: string
425
+ * identity?: string
426
+ * gender?: string
427
+ * phoneNumber?: string
428
+ * birthdate?: string
429
+ * // [items] start
430
+ * // [items] end
431
+ * remarks?: string[]
432
+ * // [items] start
433
+ * // [items] end
434
+ * tagsState?: Array<{
435
+ * key?: string
436
+ * // [items] start
437
+ * // [items] end
438
+ * annotationsState?: Array<{
439
+ * value?: string
440
+ * actor?: string
441
+ * timestamp?: string
442
+ * }>
443
+ * }>
444
+ * mainSymptom?: string
445
+ * }
446
+ * doctorState?: {
447
+ * id?: string
448
+ * name?: string
449
+ * createdTimestamp?: string
450
+ * updatedTimestamp?: string
451
+ * gender?: string
452
+ * identityNumber?: string
453
+ * phoneNumber?: string
454
+ * birthdate?: string
455
+ * }
456
+ * createdTimestamp?: string
457
+ * updatedTimestamp?: string
458
+ * status?: number
459
+ * }
460
+ * ```
461
+ *
462
+ * ---
463
+ *
464
+ * **Response**
465
+ * ```ts
466
+ * type Response = {
467
+ * id?: string
468
+ * patientState?: {
469
+ * id?: string
470
+ * doctorId?: string
471
+ * name?: string
472
+ * createdTimestamp?: string
473
+ * updatedTimestamp?: string
474
+ * identity?: string
475
+ * gender?: string
476
+ * phoneNumber?: string
477
+ * birthdate?: string
478
+ * // [items] start
479
+ * // [items] end
480
+ * remarks?: string[]
481
+ * // [items] start
482
+ * // [items] end
483
+ * tagsState?: Array<{
484
+ * key?: string
485
+ * // [items] start
486
+ * // [items] end
487
+ * annotationsState?: Array<{
488
+ * value?: string
489
+ * actor?: string
490
+ * timestamp?: string
491
+ * }>
492
+ * }>
493
+ * mainSymptom?: string
494
+ * }
495
+ * doctorState?: {
496
+ * id?: string
497
+ * name?: string
498
+ * createdTimestamp?: string
499
+ * updatedTimestamp?: string
500
+ * gender?: string
501
+ * identityNumber?: string
502
+ * phoneNumber?: string
503
+ * birthdate?: string
504
+ * }
505
+ * createdTimestamp?: string
506
+ * updatedTimestamp?: string
507
+ * status?: number
508
+ * }
509
+ * ```
510
+ */
511
+ postQueuerState<Config extends Alova2MethodConfig<QueuerState> & {
512
+ data: QueuerState;
513
+ }>(config: Config): Alova2Method<QueuerState, 'queuerRestful.postQueuerState', Config>;
514
+ };
515
+ metricRestful: {
516
+ /**
517
+ * ---
518
+ *
519
+ * [GET]
520
+ *
521
+ * **path:** /门诊/服务/统计/排队/日期
522
+ *
523
+ * ---
524
+ *
525
+ * **Response**
526
+ * ```ts
527
+ * type Response = Array<{
528
+ * date?: string
529
+ * count?: number
530
+ * }>
531
+ * ```
532
+ */
533
+ datesOfQueuerState<Config extends Alova2MethodConfig<DateDistribute[]>>(config?: Config): Alova2Method<DateDistribute[], 'metricRestful.datesOfQueuerState', Config>;
534
+ /**
535
+ * ---
536
+ *
537
+ * [GET]
538
+ *
539
+ * **path:** /门诊/服务/统计/排队/总数
540
+ *
541
+ * ---
542
+ *
543
+ * **Response**
544
+ * ```ts
545
+ * type Response = number
546
+ * ```
547
+ */
548
+ totalOfQueuerState<Config extends Alova2MethodConfig<number>>(config?: Config): Alova2Method<number, 'metricRestful.totalOfQueuerState', Config>;
549
+ /**
550
+ * ---
551
+ *
552
+ * [GET]
553
+ *
554
+ * **path:** /门诊/服务/统计/排队/今日
555
+ *
556
+ * ---
557
+ *
558
+ * **Response**
559
+ * ```ts
560
+ * type Response = number
561
+ * ```
562
+ */
563
+ totalOfQueuerTodayState<Config extends Alova2MethodConfig<number>>(config?: Config): Alova2Method<number, 'metricRestful.totalOfQueuerTodayState', Config>;
564
+ };
565
+ }
566
+ var outpatientApi: outpatientApi;
668
567
  }
568
+ export {};