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/patient/alova/globals.d.ts CHANGED
@@ -3,1671 +3,1515 @@ 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 QueryPatientStateByExactMatchRequest {
107
- id?: string[];
108
- doctorId?: string[];
109
- name?: string[];
110
- phoneNumber?: string[];
111
- gender?: string[];
112
- identityNumber?: string[];
113
- pageSize?: number;
114
- page?: number;
115
- startTime?: number;
116
- endTime?: number;
117
- sort?: string;
33
+ id?: string[];
34
+ doctorId?: string[];
35
+ name?: string[];
36
+ phoneNumber?: string[];
37
+ gender?: string[];
38
+ identityNumber?: string[];
39
+ pageSize?: number;
40
+ page?: number;
41
+ startTime?: number;
42
+ endTime?: number;
43
+ sort?: string;
118
44
  }
119
45
  export interface QueryMetaWithPatientStateRequest {
120
- ownerState?: PatientState;
121
- type?: string;
122
- pageSize?: number;
123
- page?: number;
124
- startTime?: string;
125
- endTime?: string;
126
- sort?: string;
127
- patientStartBirthdate?: string;
128
- patientEndBirthdate?: string;
129
- tagsState?: TagState[];
46
+ ownerState?: PatientState;
47
+ type?: string;
48
+ pageSize?: number;
49
+ page?: number;
50
+ startTime?: string;
51
+ endTime?: string;
52
+ sort?: string;
53
+ patientStartBirthdate?: string;
54
+ patientEndBirthdate?: string;
55
+ tagsState?: TagState[];
130
56
  }
131
57
  export interface QueryMetaStateByExactMatchRequest {
132
- id?: string[];
133
- ownerState?: PatientState[];
134
- type?: string[];
135
- pageSize?: number;
136
- page?: number;
137
- startTime?: string;
138
- endTime?: string;
139
- sort?: string;
58
+ id?: string[];
59
+ ownerState?: PatientState[];
60
+ type?: string[];
61
+ pageSize?: number;
62
+ page?: number;
63
+ startTime?: string;
64
+ endTime?: string;
65
+ sort?: string;
140
66
  }
141
67
  export interface QueryMetaStateRequest {
142
- ownerState?: PatientState;
143
- type?: string;
144
- pageSize?: number;
145
- page?: number;
146
- startTime?: string;
147
- endTime?: string;
148
- sort?: string;
68
+ ownerState?: PatientState;
69
+ type?: string;
70
+ pageSize?: number;
71
+ page?: number;
72
+ startTime?: string;
73
+ endTime?: string;
74
+ sort?: string;
149
75
  }
150
76
  export interface AgeDistribute {
151
- age?: number;
152
- count?: number;
77
+ age?: number;
78
+ count?: number;
153
79
  }
154
80
  export interface GenderDistribute {
155
- gender?: string;
156
- count?: number;
81
+ gender?: string;
82
+ count?: number;
157
83
  }
158
84
  export interface DateDistribute {
159
- date?: string;
160
- count?: number;
85
+ date?: string;
86
+ count?: number;
161
87
  }
162
88
  export interface MetaState {
163
- id?: string;
164
- ownerState?: PatientState;
165
- type?: string;
166
- tagsState?: TagState[];
167
- createdTimestamp?: string;
168
- updatedTimestamp?: string;
89
+ id?: string;
90
+ ownerState?: PatientState;
91
+ type?: string;
92
+ tagsState?: TagState[];
93
+ createdTimestamp?: string;
94
+ updatedTimestamp?: string;
169
95
  }
170
96
  export interface SortObject {
171
- empty?: boolean;
172
- sorted?: boolean;
173
- unsorted?: boolean;
97
+ empty?: boolean;
98
+ sorted?: boolean;
99
+ unsorted?: boolean;
174
100
  }
175
101
  export interface PageableObject {
176
- offset?: number;
177
- sort?: SortObject;
178
- pageSize?: number;
179
- paged?: boolean;
180
- pageNumber?: number;
181
- unpaged?: boolean;
102
+ offset?: number;
103
+ sort?: SortObject;
104
+ pageSize?: number;
105
+ paged?: boolean;
106
+ pageNumber?: number;
107
+ unpaged?: boolean;
182
108
  }
183
109
  export interface PagePatientState {
184
- totalPages?: number;
185
- totalElements?: number;
186
- size?: number;
187
- content?: PatientState[];
188
- number?: number;
189
- sort?: SortObject;
190
- first?: boolean;
191
- last?: boolean;
192
- numberOfElements?: number;
193
- pageable?: PageableObject;
194
- empty?: boolean;
110
+ totalPages?: number;
111
+ totalElements?: number;
112
+ size?: number;
113
+ content?: PatientState[];
114
+ number?: number;
115
+ sort?: SortObject;
116
+ first?: boolean;
117
+ last?: boolean;
118
+ numberOfElements?: number;
119
+ pageable?: PageableObject;
120
+ empty?: boolean;
195
121
  }
196
122
  export interface PageMetaState {
197
- totalPages?: number;
198
- totalElements?: number;
199
- size?: number;
200
- content?: MetaState[];
201
- number?: number;
202
- sort?: SortObject;
203
- first?: boolean;
204
- last?: boolean;
205
- numberOfElements?: number;
206
- pageable?: PageableObject;
207
- empty?: boolean;
123
+ totalPages?: number;
124
+ totalElements?: number;
125
+ size?: number;
126
+ content?: MetaState[];
127
+ number?: number;
128
+ sort?: SortObject;
129
+ first?: boolean;
130
+ last?: boolean;
131
+ numberOfElements?: number;
132
+ pageable?: PageableObject;
133
+ empty?: boolean;
208
134
  }
209
135
  declare global {
210
- interface patientApi {
211
- metaStateRestful: {
212
- /**
213
- * ---
214
- *
215
- * [GET]
216
- *
217
- * **path:** /患者/服务/元/{id}
218
- *
219
- * ---
220
- *
221
- * **Path Parameters**
222
- * ```ts
223
- * type PathParameters = {
224
- * id: string
225
- * }
226
- * ```
227
- *
228
- * ---
229
- *
230
- * **Response**
231
- * ```ts
232
- * type Response = {
233
- * id?: string
234
- * ownerState?: {
235
- * id?: string
236
- * doctorId?: string
237
- * name?: string
238
- * createdTimestamp?: string
239
- * updatedTimestamp?: string
240
- * identity?: string
241
- * gender?: string
242
- * phoneNumber?: string
243
- * birthdate?: string
244
- * // [items] start
245
- * // [items] end
246
- * remarks?: string[]
247
- * // [items] start
248
- * // [items] end
249
- * tagsState?: Array<{
250
- * key?: string
251
- * // [items] start
252
- * // [items] end
253
- * annotationsState?: Array<{
254
- * value?: string
255
- * actor?: string
256
- * timestamp?: string
257
- * }>
258
- * }>
259
- * mainSymptom?: string
260
- * }
261
- * type?: string
262
- * // [items] start
263
- * // [items] end
264
- * tagsState?: Array<{
265
- * key?: string
266
- * // [items] start
267
- * // [items] end
268
- * annotationsState?: Array<{
269
- * value?: string
270
- * actor?: string
271
- * timestamp?: string
272
- * }>
273
- * }>
274
- * createdTimestamp?: string
275
- * updatedTimestamp?: string
276
- * }
277
- * ```
278
- */
279
- getMetaState<
280
- Config extends Alova2MethodConfig<MetaState> & {
281
- pathParams: {
282
- id: string;
283
- };
284
- },
285
- >(
286
- config: Config,
287
- ): Alova2Method<MetaState, 'metaStateRestful.getMetaState', Config>;
288
- /**
289
- * ---
290
- *
291
- * [PUT]
292
- *
293
- * **path:** /患者/服务/元/{id}
294
- *
295
- * ---
296
- *
297
- * **Path Parameters**
298
- * ```ts
299
- * type PathParameters = {
300
- * id: string
301
- * }
302
- * ```
303
- *
304
- * ---
305
- *
306
- * **RequestBody**
307
- * ```ts
308
- * type RequestBody = {
309
- * id?: string
310
- * ownerState?: {
311
- * id?: string
312
- * doctorId?: string
313
- * name?: string
314
- * createdTimestamp?: string
315
- * updatedTimestamp?: string
316
- * identity?: string
317
- * gender?: string
318
- * phoneNumber?: string
319
- * birthdate?: string
320
- * // [items] start
321
- * // [items] end
322
- * remarks?: string[]
323
- * // [items] start
324
- * // [items] end
325
- * tagsState?: Array<{
326
- * key?: string
327
- * // [items] start
328
- * // [items] end
329
- * annotationsState?: Array<{
330
- * value?: string
331
- * actor?: string
332
- * timestamp?: string
333
- * }>
334
- * }>
335
- * mainSymptom?: string
336
- * }
337
- * type?: string
338
- * // [items] start
339
- * // [items] end
340
- * tagsState?: Array<{
341
- * key?: string
342
- * // [items] start
343
- * // [items] end
344
- * annotationsState?: Array<{
345
- * value?: string
346
- * actor?: string
347
- * timestamp?: string
348
- * }>
349
- * }>
350
- * createdTimestamp?: string
351
- * updatedTimestamp?: string
352
- * }
353
- * ```
354
- *
355
- * ---
356
- *
357
- * **Response**
358
- * ```ts
359
- * type Response = {
360
- * id?: string
361
- * ownerState?: {
362
- * id?: string
363
- * doctorId?: string
364
- * name?: string
365
- * createdTimestamp?: string
366
- * updatedTimestamp?: string
367
- * identity?: string
368
- * gender?: string
369
- * phoneNumber?: string
370
- * birthdate?: string
371
- * // [items] start
372
- * // [items] end
373
- * remarks?: string[]
374
- * // [items] start
375
- * // [items] end
376
- * tagsState?: Array<{
377
- * key?: string
378
- * // [items] start
379
- * // [items] end
380
- * annotationsState?: Array<{
381
- * value?: string
382
- * actor?: string
383
- * timestamp?: string
384
- * }>
385
- * }>
386
- * mainSymptom?: string
387
- * }
388
- * type?: string
389
- * // [items] start
390
- * // [items] end
391
- * tagsState?: Array<{
392
- * key?: string
393
- * // [items] start
394
- * // [items] end
395
- * annotationsState?: Array<{
396
- * value?: string
397
- * actor?: string
398
- * timestamp?: string
399
- * }>
400
- * }>
401
- * createdTimestamp?: string
402
- * updatedTimestamp?: string
403
- * }
404
- * ```
405
- */
406
- putMetaState<
407
- Config extends Alova2MethodConfig<MetaState> & {
408
- pathParams: {
409
- id: string;
410
- };
411
- data: MetaState;
412
- },
413
- >(
414
- config: Config,
415
- ): Alova2Method<MetaState, 'metaStateRestful.putMetaState', Config>;
416
- /**
417
- * ---
418
- *
419
- * [DELETE]
420
- *
421
- * **path:** /患者/服务/元/{id}
422
- *
423
- * ---
424
- *
425
- * **Path Parameters**
426
- * ```ts
427
- * type PathParameters = {
428
- * id: string
429
- * }
430
- * ```
431
- *
432
- * ---
433
- *
434
- * **Response**
435
- * ```ts
436
- * type Response = null
437
- * ```
438
- */
439
- deleteMetaState<
440
- Config extends Alova2MethodConfig<null> & {
441
- pathParams: {
442
- id: string;
443
- };
444
- },
445
- >(
446
- config: Config,
447
- ): Alova2Method<null, 'metaStateRestful.deleteMetaState', Config>;
448
- /**
449
- * ---
450
- *
451
- * [POST] 创建元状态记录
452
- *
453
- * **path:** /患者/服务/元
454
- *
455
- * ---
456
- *
457
- * **Query Parameters**
458
- * ```ts
459
- * type QueryParameters = {
460
- * ownerId: string
461
- * type: string
462
- * }
463
- * ```
464
- *
465
- * ---
466
- *
467
- * **RequestBody**
468
- * ```ts
469
- * type RequestBody = Blob
470
- * ```
471
- *
472
- * ---
473
- *
474
- * **Response**
475
- * ```ts
476
- * type Response = {
477
- * id?: string
478
- * ownerState?: {
479
- * id?: string
480
- * doctorId?: string
481
- * name?: string
482
- * createdTimestamp?: string
483
- * updatedTimestamp?: string
484
- * identity?: string
485
- * gender?: string
486
- * phoneNumber?: string
487
- * birthdate?: string
488
- * // [items] start
489
- * // [items] end
490
- * remarks?: string[]
491
- * // [items] start
492
- * // [items] end
493
- * tagsState?: Array<{
494
- * key?: string
495
- * // [items] start
496
- * // [items] end
497
- * annotationsState?: Array<{
498
- * value?: string
499
- * actor?: string
500
- * timestamp?: string
501
- * }>
502
- * }>
503
- * mainSymptom?: string
504
- * }
505
- * type?: string
506
- * // [items] start
507
- * // [items] end
508
- * tagsState?: Array<{
509
- * key?: string
510
- * // [items] start
511
- * // [items] end
512
- * annotationsState?: Array<{
513
- * value?: string
514
- * actor?: string
515
- * timestamp?: string
516
- * }>
517
- * }>
518
- * createdTimestamp?: string
519
- * updatedTimestamp?: string
520
- * }
521
- * ```
522
- */
523
- postMetaState<
524
- Config extends Alova2MethodConfig<MetaState> & {
525
- params: {
526
- ownerId: string;
527
- type: string;
528
- };
529
- data: Blob;
530
- },
531
- >(
532
- config: Config,
533
- ): Alova2Method<MetaState, 'metaStateRestful.postMetaState', Config>;
534
- /**
535
- * ---
536
- *
537
- * [POST]
538
- *
539
- * **path:** /患者/服务/元/级联查询
540
- *
541
- * ---
542
- *
543
- * **RequestBody**
544
- * ```ts
545
- * type RequestBody = {
546
- * ownerState?: {
547
- * id?: string
548
- * doctorId?: string
549
- * name?: string
550
- * createdTimestamp?: string
551
- * updatedTimestamp?: string
552
- * identity?: string
553
- * gender?: string
554
- * phoneNumber?: string
555
- * birthdate?: string
556
- * // [items] start
557
- * // [items] end
558
- * remarks?: string[]
559
- * // [items] start
560
- * // [items] end
561
- * tagsState?: Array<{
562
- * key?: string
563
- * // [items] start
564
- * // [items] end
565
- * annotationsState?: Array<{
566
- * value?: string
567
- * actor?: string
568
- * timestamp?: string
569
- * }>
570
- * }>
571
- * mainSymptom?: string
572
- * }
573
- * type?: string
574
- * pageSize?: number
575
- * page?: number
576
- * startTime?: string
577
- * endTime?: string
578
- * sort?: string
579
- * patientStartBirthdate?: string
580
- * patientEndBirthdate?: string
581
- * // [items] start
582
- * // [items] end
583
- * tagsState?: Array<{
584
- * key?: string
585
- * // [items] start
586
- * // [items] end
587
- * annotationsState?: Array<{
588
- * value?: string
589
- * actor?: string
590
- * timestamp?: string
591
- * }>
592
- * }>
593
- * }
594
- * ```
595
- *
596
- * ---
597
- *
598
- * **Response**
599
- * ```ts
600
- * type Response = {
601
- * totalPages?: number
602
- * totalElements?: number
603
- * size?: number
604
- * // [items] start
605
- * // [items] end
606
- * content?: Array<{
607
- * id?: string
608
- * ownerState?: {
609
- * id?: string
610
- * doctorId?: string
611
- * name?: string
612
- * createdTimestamp?: string
613
- * updatedTimestamp?: string
614
- * identity?: string
615
- * gender?: string
616
- * phoneNumber?: string
617
- * birthdate?: string
618
- * // [items] start
619
- * // [items] end
620
- * remarks?: string[]
621
- * // [items] start
622
- * // [items] end
623
- * tagsState?: Array<{
624
- * key?: string
625
- * // [items] start
626
- * // [items] end
627
- * annotationsState?: Array<{
628
- * value?: string
629
- * actor?: string
630
- * timestamp?: string
631
- * }>
632
- * }>
633
- * mainSymptom?: string
634
- * }
635
- * type?: string
636
- * // [items] start
637
- * // [items] end
638
- * tagsState?: Array<{
639
- * key?: string
640
- * // [items] start
641
- * // [items] end
642
- * annotationsState?: Array<{
643
- * value?: string
644
- * actor?: string
645
- * timestamp?: string
646
- * }>
647
- * }>
648
- * createdTimestamp?: string
649
- * updatedTimestamp?: string
650
- * }>
651
- * number?: number
652
- * sort?: {
653
- * empty?: boolean
654
- * sorted?: boolean
655
- * unsorted?: boolean
656
- * }
657
- * first?: boolean
658
- * last?: boolean
659
- * numberOfElements?: number
660
- * pageable?: {
661
- * offset?: number
662
- * sort?: {
663
- * empty?: boolean
664
- * sorted?: boolean
665
- * unsorted?: boolean
666
- * }
667
- * pageSize?: number
668
- * paged?: boolean
669
- * pageNumber?: number
670
- * unpaged?: boolean
671
- * }
672
- * empty?: boolean
673
- * }
674
- * ```
675
- */
676
- queryMetaAndPatientState<
677
- Config extends Alova2MethodConfig<PageMetaState> & {
678
- data: QueryMetaWithPatientStateRequest;
679
- },
680
- >(
681
- config: Config,
682
- ): Alova2Method<PageMetaState, 'metaStateRestful.queryMetaAndPatientState', Config>;
683
- /**
684
- * ---
685
- *
686
- * [POST]
687
- *
688
- * **path:** /患者/服务/元/精确匹配
689
- *
690
- * ---
691
- *
692
- * **RequestBody**
693
- * ```ts
694
- * type RequestBody = {
695
- * // [items] start
696
- * // [items] end
697
- * id?: string[]
698
- * // [items] start
699
- * // [items] end
700
- * ownerState?: Array<{
701
- * id?: string
702
- * doctorId?: string
703
- * name?: string
704
- * createdTimestamp?: string
705
- * updatedTimestamp?: string
706
- * identity?: string
707
- * gender?: string
708
- * phoneNumber?: string
709
- * birthdate?: string
710
- * // [items] start
711
- * // [items] end
712
- * remarks?: string[]
713
- * // [items] start
714
- * // [items] end
715
- * tagsState?: Array<{
716
- * key?: string
717
- * // [items] start
718
- * // [items] end
719
- * annotationsState?: Array<{
720
- * value?: string
721
- * actor?: string
722
- * timestamp?: string
723
- * }>
724
- * }>
725
- * mainSymptom?: string
726
- * }>
727
- * // [items] start
728
- * // [items] end
729
- * type?: string[]
730
- * pageSize?: number
731
- * page?: number
732
- * startTime?: string
733
- * endTime?: string
734
- * sort?: string
735
- * }
736
- * ```
737
- *
738
- * ---
739
- *
740
- * **Response**
741
- * ```ts
742
- * type Response = {
743
- * totalPages?: number
744
- * totalElements?: number
745
- * size?: number
746
- * // [items] start
747
- * // [items] end
748
- * content?: Array<{
749
- * id?: string
750
- * ownerState?: {
751
- * id?: string
752
- * doctorId?: string
753
- * name?: string
754
- * createdTimestamp?: string
755
- * updatedTimestamp?: string
756
- * identity?: string
757
- * gender?: string
758
- * phoneNumber?: string
759
- * birthdate?: string
760
- * // [items] start
761
- * // [items] end
762
- * remarks?: string[]
763
- * // [items] start
764
- * // [items] end
765
- * tagsState?: Array<{
766
- * key?: string
767
- * // [items] start
768
- * // [items] end
769
- * annotationsState?: Array<{
770
- * value?: string
771
- * actor?: string
772
- * timestamp?: string
773
- * }>
774
- * }>
775
- * mainSymptom?: string
776
- * }
777
- * type?: string
778
- * // [items] start
779
- * // [items] end
780
- * tagsState?: Array<{
781
- * key?: string
782
- * // [items] start
783
- * // [items] end
784
- * annotationsState?: Array<{
785
- * value?: string
786
- * actor?: string
787
- * timestamp?: string
788
- * }>
789
- * }>
790
- * createdTimestamp?: string
791
- * updatedTimestamp?: string
792
- * }>
793
- * number?: number
794
- * sort?: {
795
- * empty?: boolean
796
- * sorted?: boolean
797
- * unsorted?: boolean
798
- * }
799
- * first?: boolean
800
- * last?: boolean
801
- * numberOfElements?: number
802
- * pageable?: {
803
- * offset?: number
804
- * sort?: {
805
- * empty?: boolean
806
- * sorted?: boolean
807
- * unsorted?: boolean
808
- * }
809
- * pageSize?: number
810
- * paged?: boolean
811
- * pageNumber?: number
812
- * unpaged?: boolean
813
- * }
814
- * empty?: boolean
815
- * }
816
- * ```
817
- */
818
- queryMetaStateByExactMatch<
819
- Config extends Alova2MethodConfig<PageMetaState> & {
820
- data: QueryMetaStateByExactMatchRequest;
821
- },
822
- >(
823
- config: Config,
824
- ): Alova2Method<PageMetaState, 'metaStateRestful.queryMetaStateByExactMatch', Config>;
825
- /**
826
- * ---
827
- *
828
- * [POST]
829
- *
830
- * **path:** /患者/服务/元/条件查询
831
- *
832
- * ---
833
- *
834
- * **RequestBody**
835
- * ```ts
836
- * type RequestBody = {
837
- * ownerState?: {
838
- * id?: string
839
- * doctorId?: string
840
- * name?: string
841
- * createdTimestamp?: string
842
- * updatedTimestamp?: string
843
- * identity?: string
844
- * gender?: string
845
- * phoneNumber?: string
846
- * birthdate?: string
847
- * // [items] start
848
- * // [items] end
849
- * remarks?: string[]
850
- * // [items] start
851
- * // [items] end
852
- * tagsState?: Array<{
853
- * key?: string
854
- * // [items] start
855
- * // [items] end
856
- * annotationsState?: Array<{
857
- * value?: string
858
- * actor?: string
859
- * timestamp?: string
860
- * }>
861
- * }>
862
- * mainSymptom?: string
863
- * }
864
- * type?: string
865
- * pageSize?: number
866
- * page?: number
867
- * startTime?: string
868
- * endTime?: string
869
- * sort?: string
870
- * }
871
- * ```
872
- *
873
- * ---
874
- *
875
- * **Response**
876
- * ```ts
877
- * type Response = {
878
- * totalPages?: number
879
- * totalElements?: number
880
- * size?: number
881
- * // [items] start
882
- * // [items] end
883
- * content?: Array<{
884
- * id?: string
885
- * ownerState?: {
886
- * id?: string
887
- * doctorId?: string
888
- * name?: string
889
- * createdTimestamp?: string
890
- * updatedTimestamp?: string
891
- * identity?: string
892
- * gender?: string
893
- * phoneNumber?: string
894
- * birthdate?: string
895
- * // [items] start
896
- * // [items] end
897
- * remarks?: string[]
898
- * // [items] start
899
- * // [items] end
900
- * tagsState?: Array<{
901
- * key?: string
902
- * // [items] start
903
- * // [items] end
904
- * annotationsState?: Array<{
905
- * value?: string
906
- * actor?: string
907
- * timestamp?: string
908
- * }>
909
- * }>
910
- * mainSymptom?: string
911
- * }
912
- * type?: string
913
- * // [items] start
914
- * // [items] end
915
- * tagsState?: Array<{
916
- * key?: string
917
- * // [items] start
918
- * // [items] end
919
- * annotationsState?: Array<{
920
- * value?: string
921
- * actor?: string
922
- * timestamp?: string
923
- * }>
924
- * }>
925
- * createdTimestamp?: string
926
- * updatedTimestamp?: string
927
- * }>
928
- * number?: number
929
- * sort?: {
930
- * empty?: boolean
931
- * sorted?: boolean
932
- * unsorted?: boolean
933
- * }
934
- * first?: boolean
935
- * last?: boolean
936
- * numberOfElements?: number
937
- * pageable?: {
938
- * offset?: number
939
- * sort?: {
940
- * empty?: boolean
941
- * sorted?: boolean
942
- * unsorted?: boolean
943
- * }
944
- * pageSize?: number
945
- * paged?: boolean
946
- * pageNumber?: number
947
- * unpaged?: boolean
948
- * }
949
- * empty?: boolean
950
- * }
951
- * ```
952
- */
953
- queryMetaState<
954
- Config extends Alova2MethodConfig<PageMetaState> & {
955
- data: QueryMetaStateRequest;
956
- },
957
- >(
958
- config: Config,
959
- ): Alova2Method<PageMetaState, 'metaStateRestful.queryMetaState', Config>;
960
- /**
961
- * ---
962
- *
963
- * [GET]
964
- *
965
- * **path:** /患者/服务/元/{id}/元象
966
- *
967
- * ---
968
- *
969
- * **Path Parameters**
970
- * ```ts
971
- * type PathParameters = {
972
- * id: string
973
- * }
974
- * ```
975
- *
976
- * ---
977
- *
978
- * **Response**
979
- * ```ts
980
- * type Response = null
981
- * ```
982
- */
983
- getMetaObject<
984
- Config extends Alova2MethodConfig<null> & {
985
- pathParams: {
986
- id: string;
987
- };
988
- },
989
- >(
990
- config: Config,
991
- ): Alova2Method<null, 'metaStateRestful.getMetaObject', Config>;
992
- };
993
- patientStateRestful: {
994
- /**
995
- * ---
996
- *
997
- * [GET]
998
- *
999
- * **path:** /患者/服务/{id}
1000
- *
1001
- * ---
1002
- *
1003
- * **Path Parameters**
1004
- * ```ts
1005
- * type PathParameters = {
1006
- * id: string
1007
- * }
1008
- * ```
1009
- *
1010
- * ---
1011
- *
1012
- * **Response**
1013
- * ```ts
1014
- * type Response = {
1015
- * id?: string
1016
- * doctorId?: string
1017
- * name?: string
1018
- * createdTimestamp?: string
1019
- * updatedTimestamp?: string
1020
- * identity?: string
1021
- * gender?: string
1022
- * phoneNumber?: string
1023
- * birthdate?: string
1024
- * // [items] start
1025
- * // [items] end
1026
- * remarks?: string[]
1027
- * // [items] start
1028
- * // [items] end
1029
- * tagsState?: Array<{
1030
- * key?: string
1031
- * // [items] start
1032
- * // [items] end
1033
- * annotationsState?: Array<{
1034
- * value?: string
1035
- * actor?: string
1036
- * timestamp?: string
1037
- * }>
1038
- * }>
1039
- * mainSymptom?: string
1040
- * }
1041
- * ```
1042
- */
1043
- getPatientState<
1044
- Config extends Alova2MethodConfig<PatientState> & {
1045
- pathParams: {
1046
- id: string;
1047
- };
1048
- },
1049
- >(
1050
- config: Config,
1051
- ): Alova2Method<PatientState, 'patientStateRestful.getPatientState', Config>;
1052
- /**
1053
- * ---
1054
- *
1055
- * [PUT]
1056
- *
1057
- * **path:** /患者/服务/{id}
1058
- *
1059
- * ---
1060
- *
1061
- * **Path Parameters**
1062
- * ```ts
1063
- * type PathParameters = {
1064
- * id: string
1065
- * }
1066
- * ```
1067
- *
1068
- * ---
1069
- *
1070
- * **RequestBody**
1071
- * ```ts
1072
- * type RequestBody = {
1073
- * id?: string
1074
- * doctorId?: string
1075
- * name?: string
1076
- * createdTimestamp?: string
1077
- * updatedTimestamp?: string
1078
- * identity?: string
1079
- * gender?: string
1080
- * phoneNumber?: string
1081
- * birthdate?: string
1082
- * // [items] start
1083
- * // [items] end
1084
- * remarks?: string[]
1085
- * // [items] start
1086
- * // [items] end
1087
- * tagsState?: Array<{
1088
- * key?: string
1089
- * // [items] start
1090
- * // [items] end
1091
- * annotationsState?: Array<{
1092
- * value?: string
1093
- * actor?: string
1094
- * timestamp?: string
1095
- * }>
1096
- * }>
1097
- * mainSymptom?: string
1098
- * }
1099
- * ```
1100
- *
1101
- * ---
1102
- *
1103
- * **Response**
1104
- * ```ts
1105
- * type Response = {
1106
- * id?: string
1107
- * doctorId?: string
1108
- * name?: string
1109
- * createdTimestamp?: string
1110
- * updatedTimestamp?: string
1111
- * identity?: string
1112
- * gender?: string
1113
- * phoneNumber?: string
1114
- * birthdate?: string
1115
- * // [items] start
1116
- * // [items] end
1117
- * remarks?: string[]
1118
- * // [items] start
1119
- * // [items] end
1120
- * tagsState?: Array<{
1121
- * key?: string
1122
- * // [items] start
1123
- * // [items] end
1124
- * annotationsState?: Array<{
1125
- * value?: string
1126
- * actor?: string
1127
- * timestamp?: string
1128
- * }>
1129
- * }>
1130
- * mainSymptom?: string
1131
- * }
1132
- * ```
1133
- */
1134
- putPatientState<
1135
- Config extends Alova2MethodConfig<PatientState> & {
1136
- pathParams: {
1137
- id: string;
1138
- };
1139
- data: PatientState;
1140
- },
1141
- >(
1142
- config: Config,
1143
- ): Alova2Method<PatientState, 'patientStateRestful.putPatientState', Config>;
1144
- /**
1145
- * ---
1146
- *
1147
- * [DELETE]
1148
- *
1149
- * **path:** /患者/服务/{id}
1150
- *
1151
- * ---
1152
- *
1153
- * **Path Parameters**
1154
- * ```ts
1155
- * type PathParameters = {
1156
- * id: string
1157
- * }
1158
- * ```
1159
- *
1160
- * ---
1161
- *
1162
- * **Response**
1163
- * ```ts
1164
- * type Response = null
1165
- * ```
1166
- */
1167
- deletePatientState<
1168
- Config extends Alova2MethodConfig<null> & {
1169
- pathParams: {
1170
- id: string;
1171
- };
1172
- },
1173
- >(
1174
- config: Config,
1175
- ): Alova2Method<null, 'patientStateRestful.deletePatientState', Config>;
1176
- /**
1177
- * ---
1178
- *
1179
- * [GET]
1180
- *
1181
- * **path:** /患者/服务
1182
- *
1183
- * ---
1184
- *
1185
- * **Query Parameters**
1186
- * ```ts
1187
- * type QueryParameters = {
1188
- * id?: string
1189
- * doctorId?: string
1190
- * name?: string
1191
- * gender?: string
1192
- * identity?: string
1193
- * pageSize: number
1194
- * page: number
1195
- * phoneNumber?: string
1196
- * startTime?: string
1197
- * endTime?: string
1198
- * sort?: string
1199
- * }
1200
- * ```
1201
- *
1202
- * ---
1203
- *
1204
- * **Response**
1205
- * ```ts
1206
- * type Response = {
1207
- * totalPages?: number
1208
- * totalElements?: number
1209
- * size?: number
1210
- * // [items] start
1211
- * // [items] end
1212
- * content?: Array<{
1213
- * id?: string
1214
- * doctorId?: string
1215
- * name?: string
1216
- * createdTimestamp?: string
1217
- * updatedTimestamp?: string
1218
- * identity?: string
1219
- * gender?: string
1220
- * phoneNumber?: string
1221
- * birthdate?: string
1222
- * // [items] start
1223
- * // [items] end
1224
- * remarks?: string[]
1225
- * // [items] start
1226
- * // [items] end
1227
- * tagsState?: Array<{
1228
- * key?: string
1229
- * // [items] start
1230
- * // [items] end
1231
- * annotationsState?: Array<{
1232
- * value?: string
1233
- * actor?: string
1234
- * timestamp?: string
1235
- * }>
1236
- * }>
1237
- * mainSymptom?: string
1238
- * }>
1239
- * number?: number
1240
- * sort?: {
1241
- * empty?: boolean
1242
- * sorted?: boolean
1243
- * unsorted?: boolean
1244
- * }
1245
- * first?: boolean
1246
- * last?: boolean
1247
- * numberOfElements?: number
1248
- * pageable?: {
1249
- * offset?: number
1250
- * sort?: {
1251
- * empty?: boolean
1252
- * sorted?: boolean
1253
- * unsorted?: boolean
1254
- * }
1255
- * pageSize?: number
1256
- * paged?: boolean
1257
- * pageNumber?: number
1258
- * unpaged?: boolean
1259
- * }
1260
- * empty?: boolean
1261
- * }
1262
- * ```
1263
- */
1264
- queryPatientState<
1265
- Config extends Alova2MethodConfig<PagePatientState> & {
1266
- params: {
1267
- id?: string;
1268
- doctorId?: string;
1269
- name?: string;
1270
- gender?: string;
1271
- identity?: string;
1272
- pageSize: number;
1273
- page: number;
1274
- phoneNumber?: string;
1275
- startTime?: string;
1276
- endTime?: string;
1277
- sort?: string;
1278
- };
1279
- },
1280
- >(
1281
- config: Config,
1282
- ): Alova2Method<PagePatientState, 'patientStateRestful.queryPatientState', Config>;
1283
- /**
1284
- * ---
1285
- *
1286
- * [POST]
1287
- *
1288
- * **path:** /患者/服务
1289
- *
1290
- * ---
1291
- *
1292
- * **RequestBody**
1293
- * ```ts
1294
- * type RequestBody = {
1295
- * id?: string
1296
- * doctorId?: string
1297
- * name?: string
1298
- * createdTimestamp?: string
1299
- * updatedTimestamp?: string
1300
- * identity?: string
1301
- * gender?: string
1302
- * phoneNumber?: string
1303
- * birthdate?: string
1304
- * // [items] start
1305
- * // [items] end
1306
- * remarks?: string[]
1307
- * // [items] start
1308
- * // [items] end
1309
- * tagsState?: Array<{
1310
- * key?: string
1311
- * // [items] start
1312
- * // [items] end
1313
- * annotationsState?: Array<{
1314
- * value?: string
1315
- * actor?: string
1316
- * timestamp?: string
1317
- * }>
1318
- * }>
1319
- * mainSymptom?: string
1320
- * }
1321
- * ```
1322
- *
1323
- * ---
1324
- *
1325
- * **Response**
1326
- * ```ts
1327
- * type Response = {
1328
- * id?: string
1329
- * doctorId?: string
1330
- * name?: string
1331
- * createdTimestamp?: string
1332
- * updatedTimestamp?: string
1333
- * identity?: string
1334
- * gender?: string
1335
- * phoneNumber?: string
1336
- * birthdate?: string
1337
- * // [items] start
1338
- * // [items] end
1339
- * remarks?: string[]
1340
- * // [items] start
1341
- * // [items] end
1342
- * tagsState?: Array<{
1343
- * key?: string
1344
- * // [items] start
1345
- * // [items] end
1346
- * annotationsState?: Array<{
1347
- * value?: string
1348
- * actor?: string
1349
- * timestamp?: string
1350
- * }>
1351
- * }>
1352
- * mainSymptom?: string
1353
- * }
1354
- * ```
1355
- */
1356
- postPatientState<
1357
- Config extends Alova2MethodConfig<PatientState> & {
1358
- data: PatientState;
1359
- },
1360
- >(
1361
- config: Config,
1362
- ): Alova2Method<PatientState, 'patientStateRestful.postPatientState', Config>;
1363
- /**
1364
- * ---
1365
- *
1366
- * [POST]
1367
- *
1368
- * **path:** /患者/服务/精确匹配
1369
- *
1370
- * ---
1371
- *
1372
- * **RequestBody**
1373
- * ```ts
1374
- * type RequestBody = {
1375
- * // [items] start
1376
- * // [items] end
1377
- * id?: string[]
1378
- * // [items] start
1379
- * // [items] end
1380
- * doctorId?: string[]
1381
- * // [items] start
1382
- * // [items] end
1383
- * name?: string[]
1384
- * // [items] start
1385
- * // [items] end
1386
- * phoneNumber?: string[]
1387
- * // [items] start
1388
- * // [items] end
1389
- * gender?: string[]
1390
- * // [items] start
1391
- * // [items] end
1392
- * identityNumber?: string[]
1393
- * pageSize?: number
1394
- * page?: number
1395
- * startTime?: number
1396
- * endTime?: number
1397
- * sort?: string
1398
- * }
1399
- * ```
1400
- *
1401
- * ---
1402
- *
1403
- * **Response**
1404
- * ```ts
1405
- * type Response = {
1406
- * totalPages?: number
1407
- * totalElements?: number
1408
- * size?: number
1409
- * // [items] start
1410
- * // [items] end
1411
- * content?: Array<{
1412
- * id?: string
1413
- * doctorId?: string
1414
- * name?: string
1415
- * createdTimestamp?: string
1416
- * updatedTimestamp?: string
1417
- * identity?: string
1418
- * gender?: string
1419
- * phoneNumber?: string
1420
- * birthdate?: string
1421
- * // [items] start
1422
- * // [items] end
1423
- * remarks?: string[]
1424
- * // [items] start
1425
- * // [items] end
1426
- * tagsState?: Array<{
1427
- * key?: string
1428
- * // [items] start
1429
- * // [items] end
1430
- * annotationsState?: Array<{
1431
- * value?: string
1432
- * actor?: string
1433
- * timestamp?: string
1434
- * }>
1435
- * }>
1436
- * mainSymptom?: string
1437
- * }>
1438
- * number?: number
1439
- * sort?: {
1440
- * empty?: boolean
1441
- * sorted?: boolean
1442
- * unsorted?: boolean
1443
- * }
1444
- * first?: boolean
1445
- * last?: boolean
1446
- * numberOfElements?: number
1447
- * pageable?: {
1448
- * offset?: number
1449
- * sort?: {
1450
- * empty?: boolean
1451
- * sorted?: boolean
1452
- * unsorted?: boolean
1453
- * }
1454
- * pageSize?: number
1455
- * paged?: boolean
1456
- * pageNumber?: number
1457
- * unpaged?: boolean
1458
- * }
1459
- * empty?: boolean
1460
- * }
1461
- * ```
1462
- */
1463
- queryPatientStateByExactMatch<
1464
- Config extends Alova2MethodConfig<PagePatientState> & {
1465
- data: QueryPatientStateByExactMatchRequest;
1466
- },
1467
- >(
1468
- config: Config,
1469
- ): Alova2Method<
1470
- PagePatientState,
1471
- 'patientStateRestful.queryPatientStateByExactMatch',
1472
- Config
1473
- >;
1474
- };
1475
- metricRestful: {
1476
- /**
1477
- * ---
1478
- *
1479
- * [GET]
1480
- *
1481
- * **path:** /患者/服务/统计/患者/总数
1482
- *
1483
- * ---
1484
- *
1485
- * **Response**
1486
- * ```ts
1487
- * type Response = number
1488
- * ```
1489
- */
1490
- totalOfPatient<Config extends Alova2MethodConfig<number>>(
1491
- config?: Config,
1492
- ): Alova2Method<number, 'metricRestful.totalOfPatient', Config>;
1493
- /**
1494
- * ---
1495
- *
1496
- * [GET]
1497
- *
1498
- * **path:** /患者/服务/统计/患者/性别/分布
1499
- *
1500
- * ---
1501
- *
1502
- * **Response**
1503
- * ```ts
1504
- * type Response = Array<{
1505
- * age?: number
1506
- * count?: number
1507
- * }>
1508
- * ```
1509
- */
1510
- ageDistributeOfPatient<Config extends Alova2MethodConfig<AgeDistribute[]>>(
1511
- config?: Config,
1512
- ): Alova2Method<AgeDistribute[], 'metricRestful.ageDistributeOfPatient', Config>;
1513
- /**
1514
- * ---
1515
- *
1516
- * [GET]
1517
- *
1518
- * **path:** /患者/服务/统计/患者/年龄/分布
1519
- *
1520
- * ---
1521
- *
1522
- * **Response**
1523
- * ```ts
1524
- * type Response = Array<{
1525
- * gender?: string
1526
- * count?: number
1527
- * }>
1528
- * ```
1529
- */
1530
- genderDistributeOfPatient<Config extends Alova2MethodConfig<GenderDistribute[]>>(
1531
- config?: Config,
1532
- ): Alova2Method<GenderDistribute[], 'metricRestful.genderDistributeOfPatient', Config>;
1533
- /**
1534
- * ---
1535
- *
1536
- * [GET]
1537
- *
1538
- * **path:** /患者/服务/统计/患者/分布
1539
- *
1540
- * ---
1541
- *
1542
- * **Response**
1543
- * ```ts
1544
- * type Response = Array<{
1545
- * date?: string
1546
- * count?: number
1547
- * }>
1548
- * ```
1549
- */
1550
- dateDistributeOfPatient<Config extends Alova2MethodConfig<DateDistribute[]>>(
1551
- config?: Config,
1552
- ): Alova2Method<DateDistribute[], 'metricRestful.dateDistributeOfPatient', Config>;
1553
- /**
1554
- * ---
1555
- *
1556
- * [GET]
1557
- *
1558
- * **path:** /患者/服务/统计/患者/今日
1559
- *
1560
- * ---
1561
- *
1562
- * **Response**
1563
- * ```ts
1564
- * type Response = number
1565
- * ```
1566
- */
1567
- totalOfPatientByToday<Config extends Alova2MethodConfig<number>>(
1568
- config?: Config,
1569
- ): Alova2Method<number, 'metricRestful.totalOfPatientByToday', Config>;
1570
- /**
1571
- * ---
1572
- *
1573
- * [GET]
1574
- *
1575
- * **path:** /患者/服务/统计/元/日期
1576
- *
1577
- * ---
1578
- *
1579
- * **Query Parameters**
1580
- * ```ts
1581
- * type QueryParameters = {
1582
- * type: string
1583
- * }
1584
- * ```
1585
- *
1586
- * ---
1587
- *
1588
- * **Response**
1589
- * ```ts
1590
- * type Response = Array<{
1591
- * date?: string
1592
- * count?: number
1593
- * }>
1594
- * ```
1595
- */
1596
- datesOfMeta<
1597
- Config extends Alova2MethodConfig<DateDistribute[]> & {
1598
- params: {
1599
- type: string;
1600
- };
1601
- },
1602
- >(
1603
- config: Config,
1604
- ): Alova2Method<DateDistribute[], 'metricRestful.datesOfMeta', Config>;
1605
- /**
1606
- * ---
1607
- *
1608
- * [GET]
1609
- *
1610
- * **path:** /患者/服务/统计/元/总数
1611
- *
1612
- * ---
1613
- *
1614
- * **Query Parameters**
1615
- * ```ts
1616
- * type QueryParameters = {
1617
- * type: string
1618
- * }
1619
- * ```
1620
- *
1621
- * ---
1622
- *
1623
- * **Response**
1624
- * ```ts
1625
- * type Response = number
1626
- * ```
1627
- */
1628
- totalOfMeta<
1629
- Config extends Alova2MethodConfig<number> & {
1630
- params: {
1631
- type: string;
1632
- };
1633
- },
1634
- >(
1635
- config: Config,
1636
- ): Alova2Method<number, 'metricRestful.totalOfMeta', Config>;
1637
- /**
1638
- * ---
1639
- *
1640
- * [GET]
1641
- *
1642
- * **path:** /患者/服务/统计/元/今日
1643
- *
1644
- * ---
1645
- *
1646
- * **Query Parameters**
1647
- * ```ts
1648
- * type QueryParameters = {
1649
- * type: string
1650
- * }
1651
- * ```
1652
- *
1653
- * ---
1654
- *
1655
- * **Response**
1656
- * ```ts
1657
- * type Response = number
1658
- * ```
1659
- */
1660
- totalOfMetaByToday<
1661
- Config extends Alova2MethodConfig<number> & {
1662
- params: {
1663
- type: string;
1664
- };
1665
- },
1666
- >(
1667
- config: Config,
1668
- ): Alova2Method<number, 'metricRestful.totalOfMetaByToday', Config>;
1669
- };
1670
- }
1671
-
1672
- var patientApi: patientApi;
136
+ interface patientApi {
137
+ metaStateRestful: {
138
+ /**
139
+ * ---
140
+ *
141
+ * [GET]
142
+ *
143
+ * **path:** /患者/服务/元/{id}
144
+ *
145
+ * ---
146
+ *
147
+ * **Path Parameters**
148
+ * ```ts
149
+ * type PathParameters = {
150
+ * id: string
151
+ * }
152
+ * ```
153
+ *
154
+ * ---
155
+ *
156
+ * **Response**
157
+ * ```ts
158
+ * type Response = {
159
+ * id?: string
160
+ * ownerState?: {
161
+ * id?: string
162
+ * doctorId?: string
163
+ * name?: string
164
+ * createdTimestamp?: string
165
+ * updatedTimestamp?: string
166
+ * identity?: string
167
+ * gender?: string
168
+ * phoneNumber?: string
169
+ * birthdate?: string
170
+ * // [items] start
171
+ * // [items] end
172
+ * remarks?: string[]
173
+ * // [items] start
174
+ * // [items] end
175
+ * tagsState?: Array<{
176
+ * key?: string
177
+ * // [items] start
178
+ * // [items] end
179
+ * annotationsState?: Array<{
180
+ * value?: string
181
+ * actor?: string
182
+ * timestamp?: string
183
+ * }>
184
+ * }>
185
+ * mainSymptom?: string
186
+ * }
187
+ * type?: 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
+ * createdTimestamp?: string
201
+ * updatedTimestamp?: string
202
+ * }
203
+ * ```
204
+ */
205
+ getMetaState<Config extends Alova2MethodConfig<MetaState> & {
206
+ pathParams: {
207
+ id: string;
208
+ };
209
+ }>(config: Config): Alova2Method<MetaState, 'metaStateRestful.getMetaState', Config>;
210
+ /**
211
+ * ---
212
+ *
213
+ * [PUT]
214
+ *
215
+ * **path:** /患者/服务/元/{id}
216
+ *
217
+ * ---
218
+ *
219
+ * **Path Parameters**
220
+ * ```ts
221
+ * type PathParameters = {
222
+ * id: string
223
+ * }
224
+ * ```
225
+ *
226
+ * ---
227
+ *
228
+ * **RequestBody**
229
+ * ```ts
230
+ * type RequestBody = {
231
+ * id?: string
232
+ * ownerState?: {
233
+ * id?: string
234
+ * doctorId?: string
235
+ * name?: string
236
+ * createdTimestamp?: string
237
+ * updatedTimestamp?: string
238
+ * identity?: string
239
+ * gender?: string
240
+ * phoneNumber?: string
241
+ * birthdate?: string
242
+ * // [items] start
243
+ * // [items] end
244
+ * remarks?: string[]
245
+ * // [items] start
246
+ * // [items] end
247
+ * tagsState?: Array<{
248
+ * key?: string
249
+ * // [items] start
250
+ * // [items] end
251
+ * annotationsState?: Array<{
252
+ * value?: string
253
+ * actor?: string
254
+ * timestamp?: string
255
+ * }>
256
+ * }>
257
+ * mainSymptom?: string
258
+ * }
259
+ * type?: string
260
+ * // [items] start
261
+ * // [items] end
262
+ * tagsState?: Array<{
263
+ * key?: string
264
+ * // [items] start
265
+ * // [items] end
266
+ * annotationsState?: Array<{
267
+ * value?: string
268
+ * actor?: string
269
+ * timestamp?: string
270
+ * }>
271
+ * }>
272
+ * createdTimestamp?: string
273
+ * updatedTimestamp?: string
274
+ * }
275
+ * ```
276
+ *
277
+ * ---
278
+ *
279
+ * **Response**
280
+ * ```ts
281
+ * type Response = {
282
+ * id?: string
283
+ * ownerState?: {
284
+ * id?: string
285
+ * doctorId?: string
286
+ * name?: string
287
+ * createdTimestamp?: string
288
+ * updatedTimestamp?: string
289
+ * identity?: string
290
+ * gender?: string
291
+ * phoneNumber?: string
292
+ * birthdate?: string
293
+ * // [items] start
294
+ * // [items] end
295
+ * remarks?: string[]
296
+ * // [items] start
297
+ * // [items] end
298
+ * tagsState?: Array<{
299
+ * key?: string
300
+ * // [items] start
301
+ * // [items] end
302
+ * annotationsState?: Array<{
303
+ * value?: string
304
+ * actor?: string
305
+ * timestamp?: string
306
+ * }>
307
+ * }>
308
+ * mainSymptom?: string
309
+ * }
310
+ * type?: string
311
+ * // [items] start
312
+ * // [items] end
313
+ * tagsState?: Array<{
314
+ * key?: string
315
+ * // [items] start
316
+ * // [items] end
317
+ * annotationsState?: Array<{
318
+ * value?: string
319
+ * actor?: string
320
+ * timestamp?: string
321
+ * }>
322
+ * }>
323
+ * createdTimestamp?: string
324
+ * updatedTimestamp?: string
325
+ * }
326
+ * ```
327
+ */
328
+ putMetaState<Config extends Alova2MethodConfig<MetaState> & {
329
+ pathParams: {
330
+ id: string;
331
+ };
332
+ data: MetaState;
333
+ }>(config: Config): Alova2Method<MetaState, 'metaStateRestful.putMetaState', Config>;
334
+ /**
335
+ * ---
336
+ *
337
+ * [DELETE]
338
+ *
339
+ * **path:** /患者/服务/元/{id}
340
+ *
341
+ * ---
342
+ *
343
+ * **Path Parameters**
344
+ * ```ts
345
+ * type PathParameters = {
346
+ * id: string
347
+ * }
348
+ * ```
349
+ *
350
+ * ---
351
+ *
352
+ * **Response**
353
+ * ```ts
354
+ * type Response = null
355
+ * ```
356
+ */
357
+ deleteMetaState<Config extends Alova2MethodConfig<null> & {
358
+ pathParams: {
359
+ id: string;
360
+ };
361
+ }>(config: Config): Alova2Method<null, 'metaStateRestful.deleteMetaState', Config>;
362
+ /**
363
+ * ---
364
+ *
365
+ * [POST] 创建元状态记录
366
+ *
367
+ * **path:** /患者/服务/元
368
+ *
369
+ * ---
370
+ *
371
+ * **Query Parameters**
372
+ * ```ts
373
+ * type QueryParameters = {
374
+ * ownerId: string
375
+ * type: string
376
+ * }
377
+ * ```
378
+ *
379
+ * ---
380
+ *
381
+ * **RequestBody**
382
+ * ```ts
383
+ * type RequestBody = Blob
384
+ * ```
385
+ *
386
+ * ---
387
+ *
388
+ * **Response**
389
+ * ```ts
390
+ * type Response = {
391
+ * id?: string
392
+ * ownerState?: {
393
+ * id?: string
394
+ * doctorId?: string
395
+ * name?: string
396
+ * createdTimestamp?: string
397
+ * updatedTimestamp?: string
398
+ * identity?: string
399
+ * gender?: string
400
+ * phoneNumber?: string
401
+ * birthdate?: string
402
+ * // [items] start
403
+ * // [items] end
404
+ * remarks?: string[]
405
+ * // [items] start
406
+ * // [items] end
407
+ * tagsState?: Array<{
408
+ * key?: string
409
+ * // [items] start
410
+ * // [items] end
411
+ * annotationsState?: Array<{
412
+ * value?: string
413
+ * actor?: string
414
+ * timestamp?: string
415
+ * }>
416
+ * }>
417
+ * mainSymptom?: string
418
+ * }
419
+ * type?: string
420
+ * // [items] start
421
+ * // [items] end
422
+ * tagsState?: Array<{
423
+ * key?: string
424
+ * // [items] start
425
+ * // [items] end
426
+ * annotationsState?: Array<{
427
+ * value?: string
428
+ * actor?: string
429
+ * timestamp?: string
430
+ * }>
431
+ * }>
432
+ * createdTimestamp?: string
433
+ * updatedTimestamp?: string
434
+ * }
435
+ * ```
436
+ */
437
+ postMetaState<Config extends Alova2MethodConfig<MetaState> & {
438
+ params: {
439
+ ownerId: string;
440
+ type: string;
441
+ };
442
+ data: Blob;
443
+ }>(config: Config): Alova2Method<MetaState, 'metaStateRestful.postMetaState', Config>;
444
+ /**
445
+ * ---
446
+ *
447
+ * [POST]
448
+ *
449
+ * **path:** /患者/服务/元/级联查询
450
+ *
451
+ * ---
452
+ *
453
+ * **RequestBody**
454
+ * ```ts
455
+ * type RequestBody = {
456
+ * ownerState?: {
457
+ * id?: string
458
+ * doctorId?: string
459
+ * name?: string
460
+ * createdTimestamp?: string
461
+ * updatedTimestamp?: string
462
+ * identity?: string
463
+ * gender?: string
464
+ * phoneNumber?: string
465
+ * birthdate?: string
466
+ * // [items] start
467
+ * // [items] end
468
+ * remarks?: string[]
469
+ * // [items] start
470
+ * // [items] end
471
+ * tagsState?: Array<{
472
+ * key?: string
473
+ * // [items] start
474
+ * // [items] end
475
+ * annotationsState?: Array<{
476
+ * value?: string
477
+ * actor?: string
478
+ * timestamp?: string
479
+ * }>
480
+ * }>
481
+ * mainSymptom?: string
482
+ * }
483
+ * type?: string
484
+ * pageSize?: number
485
+ * page?: number
486
+ * startTime?: string
487
+ * endTime?: string
488
+ * sort?: string
489
+ * patientStartBirthdate?: string
490
+ * patientEndBirthdate?: string
491
+ * // [items] start
492
+ * // [items] end
493
+ * tagsState?: Array<{
494
+ * key?: string
495
+ * // [items] start
496
+ * // [items] end
497
+ * annotationsState?: Array<{
498
+ * value?: string
499
+ * actor?: string
500
+ * timestamp?: string
501
+ * }>
502
+ * }>
503
+ * }
504
+ * ```
505
+ *
506
+ * ---
507
+ *
508
+ * **Response**
509
+ * ```ts
510
+ * type Response = {
511
+ * totalPages?: number
512
+ * totalElements?: number
513
+ * size?: number
514
+ * // [items] start
515
+ * // [items] end
516
+ * content?: Array<{
517
+ * id?: string
518
+ * ownerState?: {
519
+ * id?: string
520
+ * doctorId?: string
521
+ * name?: string
522
+ * createdTimestamp?: string
523
+ * updatedTimestamp?: string
524
+ * identity?: string
525
+ * gender?: string
526
+ * phoneNumber?: string
527
+ * birthdate?: string
528
+ * // [items] start
529
+ * // [items] end
530
+ * remarks?: string[]
531
+ * // [items] start
532
+ * // [items] end
533
+ * tagsState?: Array<{
534
+ * key?: string
535
+ * // [items] start
536
+ * // [items] end
537
+ * annotationsState?: Array<{
538
+ * value?: string
539
+ * actor?: string
540
+ * timestamp?: string
541
+ * }>
542
+ * }>
543
+ * mainSymptom?: string
544
+ * }
545
+ * type?: string
546
+ * // [items] start
547
+ * // [items] end
548
+ * tagsState?: Array<{
549
+ * key?: string
550
+ * // [items] start
551
+ * // [items] end
552
+ * annotationsState?: Array<{
553
+ * value?: string
554
+ * actor?: string
555
+ * timestamp?: string
556
+ * }>
557
+ * }>
558
+ * createdTimestamp?: string
559
+ * updatedTimestamp?: string
560
+ * }>
561
+ * number?: number
562
+ * sort?: {
563
+ * empty?: boolean
564
+ * sorted?: boolean
565
+ * unsorted?: boolean
566
+ * }
567
+ * first?: boolean
568
+ * last?: boolean
569
+ * numberOfElements?: number
570
+ * pageable?: {
571
+ * offset?: number
572
+ * sort?: {
573
+ * empty?: boolean
574
+ * sorted?: boolean
575
+ * unsorted?: boolean
576
+ * }
577
+ * pageSize?: number
578
+ * paged?: boolean
579
+ * pageNumber?: number
580
+ * unpaged?: boolean
581
+ * }
582
+ * empty?: boolean
583
+ * }
584
+ * ```
585
+ */
586
+ queryMetaAndPatientState<Config extends Alova2MethodConfig<PageMetaState> & {
587
+ data: QueryMetaWithPatientStateRequest;
588
+ }>(config: Config): Alova2Method<PageMetaState, 'metaStateRestful.queryMetaAndPatientState', Config>;
589
+ /**
590
+ * ---
591
+ *
592
+ * [POST]
593
+ *
594
+ * **path:** /患者/服务/元/精确匹配
595
+ *
596
+ * ---
597
+ *
598
+ * **RequestBody**
599
+ * ```ts
600
+ * type RequestBody = {
601
+ * // [items] start
602
+ * // [items] end
603
+ * id?: string[]
604
+ * // [items] start
605
+ * // [items] end
606
+ * ownerState?: Array<{
607
+ * id?: string
608
+ * doctorId?: string
609
+ * name?: string
610
+ * createdTimestamp?: string
611
+ * updatedTimestamp?: string
612
+ * identity?: string
613
+ * gender?: string
614
+ * phoneNumber?: string
615
+ * birthdate?: string
616
+ * // [items] start
617
+ * // [items] end
618
+ * remarks?: string[]
619
+ * // [items] start
620
+ * // [items] end
621
+ * tagsState?: Array<{
622
+ * key?: string
623
+ * // [items] start
624
+ * // [items] end
625
+ * annotationsState?: Array<{
626
+ * value?: string
627
+ * actor?: string
628
+ * timestamp?: string
629
+ * }>
630
+ * }>
631
+ * mainSymptom?: string
632
+ * }>
633
+ * // [items] start
634
+ * // [items] end
635
+ * type?: string[]
636
+ * pageSize?: number
637
+ * page?: number
638
+ * startTime?: string
639
+ * endTime?: string
640
+ * sort?: string
641
+ * }
642
+ * ```
643
+ *
644
+ * ---
645
+ *
646
+ * **Response**
647
+ * ```ts
648
+ * type Response = {
649
+ * totalPages?: number
650
+ * totalElements?: number
651
+ * size?: number
652
+ * // [items] start
653
+ * // [items] end
654
+ * content?: Array<{
655
+ * id?: string
656
+ * ownerState?: {
657
+ * id?: string
658
+ * doctorId?: string
659
+ * name?: string
660
+ * createdTimestamp?: string
661
+ * updatedTimestamp?: string
662
+ * identity?: string
663
+ * gender?: string
664
+ * phoneNumber?: string
665
+ * birthdate?: string
666
+ * // [items] start
667
+ * // [items] end
668
+ * remarks?: string[]
669
+ * // [items] start
670
+ * // [items] end
671
+ * tagsState?: Array<{
672
+ * key?: string
673
+ * // [items] start
674
+ * // [items] end
675
+ * annotationsState?: Array<{
676
+ * value?: string
677
+ * actor?: string
678
+ * timestamp?: string
679
+ * }>
680
+ * }>
681
+ * mainSymptom?: string
682
+ * }
683
+ * type?: string
684
+ * // [items] start
685
+ * // [items] end
686
+ * tagsState?: Array<{
687
+ * key?: string
688
+ * // [items] start
689
+ * // [items] end
690
+ * annotationsState?: Array<{
691
+ * value?: string
692
+ * actor?: string
693
+ * timestamp?: string
694
+ * }>
695
+ * }>
696
+ * createdTimestamp?: string
697
+ * updatedTimestamp?: string
698
+ * }>
699
+ * number?: number
700
+ * sort?: {
701
+ * empty?: boolean
702
+ * sorted?: boolean
703
+ * unsorted?: boolean
704
+ * }
705
+ * first?: boolean
706
+ * last?: boolean
707
+ * numberOfElements?: number
708
+ * pageable?: {
709
+ * offset?: number
710
+ * sort?: {
711
+ * empty?: boolean
712
+ * sorted?: boolean
713
+ * unsorted?: boolean
714
+ * }
715
+ * pageSize?: number
716
+ * paged?: boolean
717
+ * pageNumber?: number
718
+ * unpaged?: boolean
719
+ * }
720
+ * empty?: boolean
721
+ * }
722
+ * ```
723
+ */
724
+ queryMetaStateByExactMatch<Config extends Alova2MethodConfig<PageMetaState> & {
725
+ data: QueryMetaStateByExactMatchRequest;
726
+ }>(config: Config): Alova2Method<PageMetaState, 'metaStateRestful.queryMetaStateByExactMatch', Config>;
727
+ /**
728
+ * ---
729
+ *
730
+ * [POST]
731
+ *
732
+ * **path:** /患者/服务/元/条件查询
733
+ *
734
+ * ---
735
+ *
736
+ * **RequestBody**
737
+ * ```ts
738
+ * type RequestBody = {
739
+ * ownerState?: {
740
+ * id?: string
741
+ * doctorId?: string
742
+ * name?: string
743
+ * createdTimestamp?: string
744
+ * updatedTimestamp?: string
745
+ * identity?: string
746
+ * gender?: string
747
+ * phoneNumber?: string
748
+ * birthdate?: string
749
+ * // [items] start
750
+ * // [items] end
751
+ * remarks?: string[]
752
+ * // [items] start
753
+ * // [items] end
754
+ * tagsState?: Array<{
755
+ * key?: string
756
+ * // [items] start
757
+ * // [items] end
758
+ * annotationsState?: Array<{
759
+ * value?: string
760
+ * actor?: string
761
+ * timestamp?: string
762
+ * }>
763
+ * }>
764
+ * mainSymptom?: string
765
+ * }
766
+ * type?: string
767
+ * pageSize?: number
768
+ * page?: number
769
+ * startTime?: string
770
+ * endTime?: string
771
+ * sort?: string
772
+ * }
773
+ * ```
774
+ *
775
+ * ---
776
+ *
777
+ * **Response**
778
+ * ```ts
779
+ * type Response = {
780
+ * totalPages?: number
781
+ * totalElements?: number
782
+ * size?: number
783
+ * // [items] start
784
+ * // [items] end
785
+ * content?: Array<{
786
+ * id?: string
787
+ * ownerState?: {
788
+ * id?: string
789
+ * doctorId?: string
790
+ * name?: string
791
+ * createdTimestamp?: string
792
+ * updatedTimestamp?: string
793
+ * identity?: string
794
+ * gender?: string
795
+ * phoneNumber?: string
796
+ * birthdate?: string
797
+ * // [items] start
798
+ * // [items] end
799
+ * remarks?: string[]
800
+ * // [items] start
801
+ * // [items] end
802
+ * tagsState?: Array<{
803
+ * key?: string
804
+ * // [items] start
805
+ * // [items] end
806
+ * annotationsState?: Array<{
807
+ * value?: string
808
+ * actor?: string
809
+ * timestamp?: string
810
+ * }>
811
+ * }>
812
+ * mainSymptom?: string
813
+ * }
814
+ * type?: string
815
+ * // [items] start
816
+ * // [items] end
817
+ * tagsState?: Array<{
818
+ * key?: string
819
+ * // [items] start
820
+ * // [items] end
821
+ * annotationsState?: Array<{
822
+ * value?: string
823
+ * actor?: string
824
+ * timestamp?: string
825
+ * }>
826
+ * }>
827
+ * createdTimestamp?: string
828
+ * updatedTimestamp?: string
829
+ * }>
830
+ * number?: number
831
+ * sort?: {
832
+ * empty?: boolean
833
+ * sorted?: boolean
834
+ * unsorted?: boolean
835
+ * }
836
+ * first?: boolean
837
+ * last?: boolean
838
+ * numberOfElements?: number
839
+ * pageable?: {
840
+ * offset?: number
841
+ * sort?: {
842
+ * empty?: boolean
843
+ * sorted?: boolean
844
+ * unsorted?: boolean
845
+ * }
846
+ * pageSize?: number
847
+ * paged?: boolean
848
+ * pageNumber?: number
849
+ * unpaged?: boolean
850
+ * }
851
+ * empty?: boolean
852
+ * }
853
+ * ```
854
+ */
855
+ queryMetaState<Config extends Alova2MethodConfig<PageMetaState> & {
856
+ data: QueryMetaStateRequest;
857
+ }>(config: Config): Alova2Method<PageMetaState, 'metaStateRestful.queryMetaState', Config>;
858
+ /**
859
+ * ---
860
+ *
861
+ * [GET]
862
+ *
863
+ * **path:** /患者/服务/元/{id}/元象
864
+ *
865
+ * ---
866
+ *
867
+ * **Path Parameters**
868
+ * ```ts
869
+ * type PathParameters = {
870
+ * id: string
871
+ * }
872
+ * ```
873
+ *
874
+ * ---
875
+ *
876
+ * **Response**
877
+ * ```ts
878
+ * type Response = null
879
+ * ```
880
+ */
881
+ getMetaObject<Config extends Alova2MethodConfig<null> & {
882
+ pathParams: {
883
+ id: string;
884
+ };
885
+ }>(config: Config): Alova2Method<null, 'metaStateRestful.getMetaObject', Config>;
886
+ };
887
+ patientStateRestful: {
888
+ /**
889
+ * ---
890
+ *
891
+ * [GET]
892
+ *
893
+ * **path:** /患者/服务/{id}
894
+ *
895
+ * ---
896
+ *
897
+ * **Path Parameters**
898
+ * ```ts
899
+ * type PathParameters = {
900
+ * id: string
901
+ * }
902
+ * ```
903
+ *
904
+ * ---
905
+ *
906
+ * **Response**
907
+ * ```ts
908
+ * type Response = {
909
+ * id?: string
910
+ * doctorId?: string
911
+ * name?: string
912
+ * createdTimestamp?: string
913
+ * updatedTimestamp?: string
914
+ * identity?: string
915
+ * gender?: string
916
+ * phoneNumber?: string
917
+ * birthdate?: string
918
+ * // [items] start
919
+ * // [items] end
920
+ * remarks?: string[]
921
+ * // [items] start
922
+ * // [items] end
923
+ * tagsState?: Array<{
924
+ * key?: string
925
+ * // [items] start
926
+ * // [items] end
927
+ * annotationsState?: Array<{
928
+ * value?: string
929
+ * actor?: string
930
+ * timestamp?: string
931
+ * }>
932
+ * }>
933
+ * mainSymptom?: string
934
+ * }
935
+ * ```
936
+ */
937
+ getPatientState<Config extends Alova2MethodConfig<PatientState> & {
938
+ pathParams: {
939
+ id: string;
940
+ };
941
+ }>(config: Config): Alova2Method<PatientState, 'patientStateRestful.getPatientState', Config>;
942
+ /**
943
+ * ---
944
+ *
945
+ * [PUT]
946
+ *
947
+ * **path:** /患者/服务/{id}
948
+ *
949
+ * ---
950
+ *
951
+ * **Path Parameters**
952
+ * ```ts
953
+ * type PathParameters = {
954
+ * id: string
955
+ * }
956
+ * ```
957
+ *
958
+ * ---
959
+ *
960
+ * **RequestBody**
961
+ * ```ts
962
+ * type RequestBody = {
963
+ * id?: string
964
+ * doctorId?: string
965
+ * name?: string
966
+ * createdTimestamp?: string
967
+ * updatedTimestamp?: string
968
+ * identity?: string
969
+ * gender?: string
970
+ * phoneNumber?: string
971
+ * birthdate?: string
972
+ * // [items] start
973
+ * // [items] end
974
+ * remarks?: string[]
975
+ * // [items] start
976
+ * // [items] end
977
+ * tagsState?: Array<{
978
+ * key?: string
979
+ * // [items] start
980
+ * // [items] end
981
+ * annotationsState?: Array<{
982
+ * value?: string
983
+ * actor?: string
984
+ * timestamp?: string
985
+ * }>
986
+ * }>
987
+ * mainSymptom?: string
988
+ * }
989
+ * ```
990
+ *
991
+ * ---
992
+ *
993
+ * **Response**
994
+ * ```ts
995
+ * type Response = {
996
+ * id?: string
997
+ * doctorId?: string
998
+ * name?: string
999
+ * createdTimestamp?: string
1000
+ * updatedTimestamp?: string
1001
+ * identity?: string
1002
+ * gender?: string
1003
+ * phoneNumber?: string
1004
+ * birthdate?: string
1005
+ * // [items] start
1006
+ * // [items] end
1007
+ * remarks?: string[]
1008
+ * // [items] start
1009
+ * // [items] end
1010
+ * tagsState?: Array<{
1011
+ * key?: string
1012
+ * // [items] start
1013
+ * // [items] end
1014
+ * annotationsState?: Array<{
1015
+ * value?: string
1016
+ * actor?: string
1017
+ * timestamp?: string
1018
+ * }>
1019
+ * }>
1020
+ * mainSymptom?: string
1021
+ * }
1022
+ * ```
1023
+ */
1024
+ putPatientState<Config extends Alova2MethodConfig<PatientState> & {
1025
+ pathParams: {
1026
+ id: string;
1027
+ };
1028
+ data: PatientState;
1029
+ }>(config: Config): Alova2Method<PatientState, 'patientStateRestful.putPatientState', Config>;
1030
+ /**
1031
+ * ---
1032
+ *
1033
+ * [DELETE]
1034
+ *
1035
+ * **path:** /患者/服务/{id}
1036
+ *
1037
+ * ---
1038
+ *
1039
+ * **Path Parameters**
1040
+ * ```ts
1041
+ * type PathParameters = {
1042
+ * id: string
1043
+ * }
1044
+ * ```
1045
+ *
1046
+ * ---
1047
+ *
1048
+ * **Response**
1049
+ * ```ts
1050
+ * type Response = null
1051
+ * ```
1052
+ */
1053
+ deletePatientState<Config extends Alova2MethodConfig<null> & {
1054
+ pathParams: {
1055
+ id: string;
1056
+ };
1057
+ }>(config: Config): Alova2Method<null, 'patientStateRestful.deletePatientState', Config>;
1058
+ /**
1059
+ * ---
1060
+ *
1061
+ * [GET]
1062
+ *
1063
+ * **path:** /患者/服务
1064
+ *
1065
+ * ---
1066
+ *
1067
+ * **Query Parameters**
1068
+ * ```ts
1069
+ * type QueryParameters = {
1070
+ * id?: string
1071
+ * doctorId?: string
1072
+ * name?: string
1073
+ * gender?: string
1074
+ * identity?: string
1075
+ * pageSize: number
1076
+ * page: number
1077
+ * phoneNumber?: string
1078
+ * startTime?: string
1079
+ * endTime?: string
1080
+ * sort?: string
1081
+ * }
1082
+ * ```
1083
+ *
1084
+ * ---
1085
+ *
1086
+ * **Response**
1087
+ * ```ts
1088
+ * type Response = {
1089
+ * totalPages?: number
1090
+ * totalElements?: number
1091
+ * size?: number
1092
+ * // [items] start
1093
+ * // [items] end
1094
+ * content?: Array<{
1095
+ * id?: string
1096
+ * doctorId?: string
1097
+ * name?: string
1098
+ * createdTimestamp?: string
1099
+ * updatedTimestamp?: string
1100
+ * identity?: string
1101
+ * gender?: string
1102
+ * phoneNumber?: string
1103
+ * birthdate?: string
1104
+ * // [items] start
1105
+ * // [items] end
1106
+ * remarks?: string[]
1107
+ * // [items] start
1108
+ * // [items] end
1109
+ * tagsState?: Array<{
1110
+ * key?: string
1111
+ * // [items] start
1112
+ * // [items] end
1113
+ * annotationsState?: Array<{
1114
+ * value?: string
1115
+ * actor?: string
1116
+ * timestamp?: string
1117
+ * }>
1118
+ * }>
1119
+ * mainSymptom?: string
1120
+ * }>
1121
+ * number?: number
1122
+ * sort?: {
1123
+ * empty?: boolean
1124
+ * sorted?: boolean
1125
+ * unsorted?: boolean
1126
+ * }
1127
+ * first?: boolean
1128
+ * last?: boolean
1129
+ * numberOfElements?: number
1130
+ * pageable?: {
1131
+ * offset?: number
1132
+ * sort?: {
1133
+ * empty?: boolean
1134
+ * sorted?: boolean
1135
+ * unsorted?: boolean
1136
+ * }
1137
+ * pageSize?: number
1138
+ * paged?: boolean
1139
+ * pageNumber?: number
1140
+ * unpaged?: boolean
1141
+ * }
1142
+ * empty?: boolean
1143
+ * }
1144
+ * ```
1145
+ */
1146
+ queryPatientState<Config extends Alova2MethodConfig<PagePatientState> & {
1147
+ params: {
1148
+ id?: string;
1149
+ doctorId?: string;
1150
+ name?: string;
1151
+ gender?: string;
1152
+ identity?: string;
1153
+ pageSize: number;
1154
+ page: number;
1155
+ phoneNumber?: string;
1156
+ startTime?: string;
1157
+ endTime?: string;
1158
+ sort?: string;
1159
+ };
1160
+ }>(config: Config): Alova2Method<PagePatientState, 'patientStateRestful.queryPatientState', Config>;
1161
+ /**
1162
+ * ---
1163
+ *
1164
+ * [POST]
1165
+ *
1166
+ * **path:** /患者/服务
1167
+ *
1168
+ * ---
1169
+ *
1170
+ * **RequestBody**
1171
+ * ```ts
1172
+ * type RequestBody = {
1173
+ * id?: string
1174
+ * doctorId?: string
1175
+ * name?: string
1176
+ * createdTimestamp?: string
1177
+ * updatedTimestamp?: string
1178
+ * identity?: string
1179
+ * gender?: string
1180
+ * phoneNumber?: string
1181
+ * birthdate?: string
1182
+ * // [items] start
1183
+ * // [items] end
1184
+ * remarks?: string[]
1185
+ * // [items] start
1186
+ * // [items] end
1187
+ * tagsState?: Array<{
1188
+ * key?: string
1189
+ * // [items] start
1190
+ * // [items] end
1191
+ * annotationsState?: Array<{
1192
+ * value?: string
1193
+ * actor?: string
1194
+ * timestamp?: string
1195
+ * }>
1196
+ * }>
1197
+ * mainSymptom?: string
1198
+ * }
1199
+ * ```
1200
+ *
1201
+ * ---
1202
+ *
1203
+ * **Response**
1204
+ * ```ts
1205
+ * type Response = {
1206
+ * id?: string
1207
+ * doctorId?: string
1208
+ * name?: string
1209
+ * createdTimestamp?: string
1210
+ * updatedTimestamp?: string
1211
+ * identity?: string
1212
+ * gender?: string
1213
+ * phoneNumber?: string
1214
+ * birthdate?: string
1215
+ * // [items] start
1216
+ * // [items] end
1217
+ * remarks?: string[]
1218
+ * // [items] start
1219
+ * // [items] end
1220
+ * tagsState?: Array<{
1221
+ * key?: string
1222
+ * // [items] start
1223
+ * // [items] end
1224
+ * annotationsState?: Array<{
1225
+ * value?: string
1226
+ * actor?: string
1227
+ * timestamp?: string
1228
+ * }>
1229
+ * }>
1230
+ * mainSymptom?: string
1231
+ * }
1232
+ * ```
1233
+ */
1234
+ postPatientState<Config extends Alova2MethodConfig<PatientState> & {
1235
+ data: PatientState;
1236
+ }>(config: Config): Alova2Method<PatientState, 'patientStateRestful.postPatientState', Config>;
1237
+ /**
1238
+ * ---
1239
+ *
1240
+ * [POST]
1241
+ *
1242
+ * **path:** /患者/服务/精确匹配
1243
+ *
1244
+ * ---
1245
+ *
1246
+ * **RequestBody**
1247
+ * ```ts
1248
+ * type RequestBody = {
1249
+ * // [items] start
1250
+ * // [items] end
1251
+ * id?: string[]
1252
+ * // [items] start
1253
+ * // [items] end
1254
+ * doctorId?: string[]
1255
+ * // [items] start
1256
+ * // [items] end
1257
+ * name?: string[]
1258
+ * // [items] start
1259
+ * // [items] end
1260
+ * phoneNumber?: string[]
1261
+ * // [items] start
1262
+ * // [items] end
1263
+ * gender?: string[]
1264
+ * // [items] start
1265
+ * // [items] end
1266
+ * identityNumber?: string[]
1267
+ * pageSize?: number
1268
+ * page?: number
1269
+ * startTime?: number
1270
+ * endTime?: number
1271
+ * sort?: string
1272
+ * }
1273
+ * ```
1274
+ *
1275
+ * ---
1276
+ *
1277
+ * **Response**
1278
+ * ```ts
1279
+ * type Response = {
1280
+ * totalPages?: number
1281
+ * totalElements?: number
1282
+ * size?: number
1283
+ * // [items] start
1284
+ * // [items] end
1285
+ * content?: Array<{
1286
+ * id?: string
1287
+ * doctorId?: string
1288
+ * name?: string
1289
+ * createdTimestamp?: string
1290
+ * updatedTimestamp?: string
1291
+ * identity?: string
1292
+ * gender?: string
1293
+ * phoneNumber?: string
1294
+ * birthdate?: string
1295
+ * // [items] start
1296
+ * // [items] end
1297
+ * remarks?: string[]
1298
+ * // [items] start
1299
+ * // [items] end
1300
+ * tagsState?: Array<{
1301
+ * key?: string
1302
+ * // [items] start
1303
+ * // [items] end
1304
+ * annotationsState?: Array<{
1305
+ * value?: string
1306
+ * actor?: string
1307
+ * timestamp?: string
1308
+ * }>
1309
+ * }>
1310
+ * mainSymptom?: string
1311
+ * }>
1312
+ * number?: number
1313
+ * sort?: {
1314
+ * empty?: boolean
1315
+ * sorted?: boolean
1316
+ * unsorted?: boolean
1317
+ * }
1318
+ * first?: boolean
1319
+ * last?: boolean
1320
+ * numberOfElements?: number
1321
+ * pageable?: {
1322
+ * offset?: number
1323
+ * sort?: {
1324
+ * empty?: boolean
1325
+ * sorted?: boolean
1326
+ * unsorted?: boolean
1327
+ * }
1328
+ * pageSize?: number
1329
+ * paged?: boolean
1330
+ * pageNumber?: number
1331
+ * unpaged?: boolean
1332
+ * }
1333
+ * empty?: boolean
1334
+ * }
1335
+ * ```
1336
+ */
1337
+ queryPatientStateByExactMatch<Config extends Alova2MethodConfig<PagePatientState> & {
1338
+ data: QueryPatientStateByExactMatchRequest;
1339
+ }>(config: Config): Alova2Method<PagePatientState, 'patientStateRestful.queryPatientStateByExactMatch', Config>;
1340
+ };
1341
+ metricRestful: {
1342
+ /**
1343
+ * ---
1344
+ *
1345
+ * [GET]
1346
+ *
1347
+ * **path:** /患者/服务/统计/患者/总数
1348
+ *
1349
+ * ---
1350
+ *
1351
+ * **Response**
1352
+ * ```ts
1353
+ * type Response = number
1354
+ * ```
1355
+ */
1356
+ totalOfPatient<Config extends Alova2MethodConfig<number>>(config?: Config): Alova2Method<number, 'metricRestful.totalOfPatient', Config>;
1357
+ /**
1358
+ * ---
1359
+ *
1360
+ * [GET]
1361
+ *
1362
+ * **path:** /患者/服务/统计/患者/性别/分布
1363
+ *
1364
+ * ---
1365
+ *
1366
+ * **Response**
1367
+ * ```ts
1368
+ * type Response = Array<{
1369
+ * age?: number
1370
+ * count?: number
1371
+ * }>
1372
+ * ```
1373
+ */
1374
+ ageDistributeOfPatient<Config extends Alova2MethodConfig<AgeDistribute[]>>(config?: Config): Alova2Method<AgeDistribute[], 'metricRestful.ageDistributeOfPatient', Config>;
1375
+ /**
1376
+ * ---
1377
+ *
1378
+ * [GET]
1379
+ *
1380
+ * **path:** /患者/服务/统计/患者/年龄/分布
1381
+ *
1382
+ * ---
1383
+ *
1384
+ * **Response**
1385
+ * ```ts
1386
+ * type Response = Array<{
1387
+ * gender?: string
1388
+ * count?: number
1389
+ * }>
1390
+ * ```
1391
+ */
1392
+ genderDistributeOfPatient<Config extends Alova2MethodConfig<GenderDistribute[]>>(config?: Config): Alova2Method<GenderDistribute[], 'metricRestful.genderDistributeOfPatient', Config>;
1393
+ /**
1394
+ * ---
1395
+ *
1396
+ * [GET]
1397
+ *
1398
+ * **path:** /患者/服务/统计/患者/分布
1399
+ *
1400
+ * ---
1401
+ *
1402
+ * **Response**
1403
+ * ```ts
1404
+ * type Response = Array<{
1405
+ * date?: string
1406
+ * count?: number
1407
+ * }>
1408
+ * ```
1409
+ */
1410
+ dateDistributeOfPatient<Config extends Alova2MethodConfig<DateDistribute[]>>(config?: Config): Alova2Method<DateDistribute[], 'metricRestful.dateDistributeOfPatient', Config>;
1411
+ /**
1412
+ * ---
1413
+ *
1414
+ * [GET]
1415
+ *
1416
+ * **path:** /患者/服务/统计/患者/今日
1417
+ *
1418
+ * ---
1419
+ *
1420
+ * **Response**
1421
+ * ```ts
1422
+ * type Response = number
1423
+ * ```
1424
+ */
1425
+ totalOfPatientByToday<Config extends Alova2MethodConfig<number>>(config?: Config): Alova2Method<number, 'metricRestful.totalOfPatientByToday', Config>;
1426
+ /**
1427
+ * ---
1428
+ *
1429
+ * [GET]
1430
+ *
1431
+ * **path:** /患者/服务/统计/元/日期
1432
+ *
1433
+ * ---
1434
+ *
1435
+ * **Query Parameters**
1436
+ * ```ts
1437
+ * type QueryParameters = {
1438
+ * type: string
1439
+ * }
1440
+ * ```
1441
+ *
1442
+ * ---
1443
+ *
1444
+ * **Response**
1445
+ * ```ts
1446
+ * type Response = Array<{
1447
+ * date?: string
1448
+ * count?: number
1449
+ * }>
1450
+ * ```
1451
+ */
1452
+ datesOfMeta<Config extends Alova2MethodConfig<DateDistribute[]> & {
1453
+ params: {
1454
+ type: string;
1455
+ };
1456
+ }>(config: Config): Alova2Method<DateDistribute[], 'metricRestful.datesOfMeta', Config>;
1457
+ /**
1458
+ * ---
1459
+ *
1460
+ * [GET]
1461
+ *
1462
+ * **path:** /患者/服务/统计/元/总数
1463
+ *
1464
+ * ---
1465
+ *
1466
+ * **Query Parameters**
1467
+ * ```ts
1468
+ * type QueryParameters = {
1469
+ * type: string
1470
+ * }
1471
+ * ```
1472
+ *
1473
+ * ---
1474
+ *
1475
+ * **Response**
1476
+ * ```ts
1477
+ * type Response = number
1478
+ * ```
1479
+ */
1480
+ totalOfMeta<Config extends Alova2MethodConfig<number> & {
1481
+ params: {
1482
+ type: string;
1483
+ };
1484
+ }>(config: Config): Alova2Method<number, 'metricRestful.totalOfMeta', Config>;
1485
+ /**
1486
+ * ---
1487
+ *
1488
+ * [GET]
1489
+ *
1490
+ * **path:** /患者/服务/统计/元/今日
1491
+ *
1492
+ * ---
1493
+ *
1494
+ * **Query Parameters**
1495
+ * ```ts
1496
+ * type QueryParameters = {
1497
+ * type: string
1498
+ * }
1499
+ * ```
1500
+ *
1501
+ * ---
1502
+ *
1503
+ * **Response**
1504
+ * ```ts
1505
+ * type Response = number
1506
+ * ```
1507
+ */
1508
+ totalOfMetaByToday<Config extends Alova2MethodConfig<number> & {
1509
+ params: {
1510
+ type: string;
1511
+ };
1512
+ }>(config: Config): Alova2Method<number, 'metricRestful.totalOfMetaByToday', Config>;
1513
+ };
1514
+ }
1515
+ var patientApi: patientApi;
1673
1516
  }
1517
+ export {};