@metriport/commonwell-sdk 3.1.1 → 3.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/models/address.d.ts +6 -6
- package/lib/models/certificates.d.ts +13 -13
- package/lib/models/contact.d.ts +4 -4
- package/lib/models/demographics.d.ts +48 -49
- package/lib/models/document.d.ts +723 -723
- package/lib/models/facility.d.ts +16 -16
- package/lib/models/human-name.d.ts +8 -8
- package/lib/models/identifier.d.ts +2 -3
- package/lib/models/link.d.ts +116 -117
- package/lib/models/organization.d.ts +140 -140
- package/lib/models/patient.d.ts +954 -959
- package/lib/models/person.d.ts +593 -595
- package/package.json +2 -2
- package/lib/models/commonwell.d.ts +0 -49
- package/lib/models/commonwell.js +0 -3
- package/lib/models/commonwell.js.map +0 -1
package/lib/models/patient.d.ts
CHANGED
|
@@ -5,12 +5,12 @@ export declare const patientOrganizationSchema: z.ZodObject<{
|
|
|
5
5
|
display: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
6
6
|
}, "strip", z.ZodTypeAny, {
|
|
7
7
|
type?: string;
|
|
8
|
-
display?: string;
|
|
9
8
|
reference?: string;
|
|
9
|
+
display?: string;
|
|
10
10
|
}, {
|
|
11
11
|
type?: string;
|
|
12
|
-
display?: string;
|
|
13
12
|
reference?: string;
|
|
13
|
+
display?: string;
|
|
14
14
|
}>;
|
|
15
15
|
export declare const patientLinksSchema: z.ZodObject<{
|
|
16
16
|
self: z.ZodObject<{
|
|
@@ -18,148 +18,147 @@ export declare const patientLinksSchema: z.ZodObject<{
|
|
|
18
18
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
19
19
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
20
20
|
}, "strip", z.ZodTypeAny, {
|
|
21
|
-
type?: string;
|
|
22
21
|
href?: string;
|
|
23
22
|
templated?: boolean;
|
|
24
|
-
}, {
|
|
25
23
|
type?: string;
|
|
24
|
+
}, {
|
|
26
25
|
href?: string;
|
|
27
26
|
templated?: boolean;
|
|
27
|
+
type?: string;
|
|
28
28
|
}>;
|
|
29
29
|
networkLink: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
30
30
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
31
31
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
32
32
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
33
33
|
}, "strip", z.ZodTypeAny, {
|
|
34
|
-
type?: string;
|
|
35
34
|
href?: string;
|
|
36
35
|
templated?: boolean;
|
|
37
|
-
}, {
|
|
38
36
|
type?: string;
|
|
37
|
+
}, {
|
|
39
38
|
href?: string;
|
|
40
39
|
templated?: boolean;
|
|
40
|
+
type?: string;
|
|
41
41
|
}>>>;
|
|
42
42
|
person: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
43
43
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
44
44
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
45
45
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
46
46
|
}, "strip", z.ZodTypeAny, {
|
|
47
|
-
type?: string;
|
|
48
47
|
href?: string;
|
|
49
48
|
templated?: boolean;
|
|
50
|
-
}, {
|
|
51
49
|
type?: string;
|
|
50
|
+
}, {
|
|
52
51
|
href?: string;
|
|
53
52
|
templated?: boolean;
|
|
53
|
+
type?: string;
|
|
54
54
|
}>>>;
|
|
55
55
|
personMatch: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
56
56
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
57
57
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
58
58
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
59
59
|
}, "strip", z.ZodTypeAny, {
|
|
60
|
-
type?: string;
|
|
61
60
|
href?: string;
|
|
62
61
|
templated?: boolean;
|
|
63
|
-
}, {
|
|
64
62
|
type?: string;
|
|
63
|
+
}, {
|
|
65
64
|
href?: string;
|
|
66
65
|
templated?: boolean;
|
|
66
|
+
type?: string;
|
|
67
67
|
}>>>;
|
|
68
68
|
upgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
69
69
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
70
70
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
71
71
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
72
72
|
}, "strip", z.ZodTypeAny, {
|
|
73
|
-
type?: string;
|
|
74
73
|
href?: string;
|
|
75
74
|
templated?: boolean;
|
|
76
|
-
}, {
|
|
77
75
|
type?: string;
|
|
76
|
+
}, {
|
|
78
77
|
href?: string;
|
|
79
78
|
templated?: boolean;
|
|
79
|
+
type?: string;
|
|
80
80
|
}>>>;
|
|
81
81
|
downgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
82
82
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
83
83
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
84
84
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
85
85
|
}, "strip", z.ZodTypeAny, {
|
|
86
|
-
type?: string;
|
|
87
86
|
href?: string;
|
|
88
87
|
templated?: boolean;
|
|
89
|
-
}, {
|
|
90
88
|
type?: string;
|
|
89
|
+
}, {
|
|
91
90
|
href?: string;
|
|
92
91
|
templated?: boolean;
|
|
92
|
+
type?: string;
|
|
93
93
|
}>>>;
|
|
94
94
|
}, "strip", z.ZodTypeAny, {
|
|
95
95
|
self?: {
|
|
96
|
-
type?: string;
|
|
97
96
|
href?: string;
|
|
98
97
|
templated?: boolean;
|
|
99
|
-
};
|
|
100
|
-
upgrade?: {
|
|
101
98
|
type?: string;
|
|
102
|
-
href?: string;
|
|
103
|
-
templated?: boolean;
|
|
104
99
|
};
|
|
105
|
-
|
|
106
|
-
type?: string;
|
|
100
|
+
networkLink?: {
|
|
107
101
|
href?: string;
|
|
108
102
|
templated?: boolean;
|
|
103
|
+
type?: string;
|
|
109
104
|
};
|
|
110
105
|
person?: {
|
|
111
|
-
type?: string;
|
|
112
106
|
href?: string;
|
|
113
107
|
templated?: boolean;
|
|
114
|
-
};
|
|
115
|
-
networkLink?: {
|
|
116
108
|
type?: string;
|
|
117
|
-
href?: string;
|
|
118
|
-
templated?: boolean;
|
|
119
109
|
};
|
|
120
110
|
personMatch?: {
|
|
121
|
-
type?: string;
|
|
122
111
|
href?: string;
|
|
123
112
|
templated?: boolean;
|
|
124
|
-
};
|
|
125
|
-
}, {
|
|
126
|
-
self?: {
|
|
127
113
|
type?: string;
|
|
128
|
-
href?: string;
|
|
129
|
-
templated?: boolean;
|
|
130
114
|
};
|
|
131
115
|
upgrade?: {
|
|
132
|
-
type?: string;
|
|
133
116
|
href?: string;
|
|
134
117
|
templated?: boolean;
|
|
118
|
+
type?: string;
|
|
135
119
|
};
|
|
136
120
|
downgrade?: {
|
|
137
|
-
type?: string;
|
|
138
121
|
href?: string;
|
|
139
122
|
templated?: boolean;
|
|
140
|
-
};
|
|
141
|
-
person?: {
|
|
142
123
|
type?: string;
|
|
124
|
+
};
|
|
125
|
+
}, {
|
|
126
|
+
self?: {
|
|
143
127
|
href?: string;
|
|
144
128
|
templated?: boolean;
|
|
129
|
+
type?: string;
|
|
145
130
|
};
|
|
146
131
|
networkLink?: {
|
|
132
|
+
href?: string;
|
|
133
|
+
templated?: boolean;
|
|
147
134
|
type?: string;
|
|
135
|
+
};
|
|
136
|
+
person?: {
|
|
148
137
|
href?: string;
|
|
149
138
|
templated?: boolean;
|
|
139
|
+
type?: string;
|
|
150
140
|
};
|
|
151
141
|
personMatch?: {
|
|
142
|
+
href?: string;
|
|
143
|
+
templated?: boolean;
|
|
152
144
|
type?: string;
|
|
145
|
+
};
|
|
146
|
+
upgrade?: {
|
|
147
|
+
href?: string;
|
|
148
|
+
templated?: boolean;
|
|
149
|
+
type?: string;
|
|
150
|
+
};
|
|
151
|
+
downgrade?: {
|
|
153
152
|
href?: string;
|
|
154
153
|
templated?: boolean;
|
|
154
|
+
type?: string;
|
|
155
155
|
};
|
|
156
156
|
}>;
|
|
157
157
|
export declare const patientSchema: z.ZodObject<{
|
|
158
158
|
active: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
159
|
-
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<
|
|
159
|
+
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
160
160
|
system: z.ZodString;
|
|
161
161
|
key: z.ZodString;
|
|
162
|
-
}, {
|
|
163
162
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
164
163
|
label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
165
164
|
period: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
@@ -173,7 +172,7 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
173
172
|
end?: string;
|
|
174
173
|
}>>>;
|
|
175
174
|
assigner: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
176
|
-
}
|
|
175
|
+
}, "strip", z.ZodTypeAny, {
|
|
177
176
|
system?: string;
|
|
178
177
|
key?: string;
|
|
179
178
|
use?: string;
|
|
@@ -200,18 +199,17 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
200
199
|
display: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
201
200
|
}, "strip", z.ZodTypeAny, {
|
|
202
201
|
type?: string;
|
|
203
|
-
display?: string;
|
|
204
202
|
reference?: string;
|
|
203
|
+
display?: string;
|
|
205
204
|
}, {
|
|
206
205
|
type?: string;
|
|
207
|
-
display?: string;
|
|
208
206
|
reference?: string;
|
|
207
|
+
display?: string;
|
|
209
208
|
}>>>;
|
|
210
209
|
details: z.ZodObject<{
|
|
211
|
-
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<
|
|
210
|
+
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
212
211
|
system: z.ZodString;
|
|
213
212
|
key: z.ZodString;
|
|
214
|
-
}, {
|
|
215
213
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
216
214
|
label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
217
215
|
period: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
@@ -225,7 +223,7 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
225
223
|
end?: string;
|
|
226
224
|
}>>>;
|
|
227
225
|
assigner: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
228
|
-
}
|
|
226
|
+
}, "strip", z.ZodTypeAny, {
|
|
229
227
|
system?: string;
|
|
230
228
|
key?: string;
|
|
231
229
|
use?: string;
|
|
@@ -264,27 +262,27 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
264
262
|
end?: string;
|
|
265
263
|
}>>>;
|
|
266
264
|
}, "strip", z.ZodTypeAny, {
|
|
267
|
-
text?: string;
|
|
268
265
|
use?: string;
|
|
269
|
-
|
|
270
|
-
start?: string;
|
|
271
|
-
end?: string;
|
|
272
|
-
};
|
|
266
|
+
text?: string;
|
|
273
267
|
family?: string[];
|
|
274
268
|
given?: string[];
|
|
275
269
|
prefix?: string;
|
|
276
270
|
suffix?: string;
|
|
277
|
-
}, {
|
|
278
|
-
text?: string;
|
|
279
|
-
use?: string;
|
|
280
271
|
period?: {
|
|
281
272
|
start?: string;
|
|
282
273
|
end?: string;
|
|
283
274
|
};
|
|
275
|
+
}, {
|
|
276
|
+
use?: string;
|
|
277
|
+
text?: string;
|
|
284
278
|
family?: string[];
|
|
285
279
|
given?: string[];
|
|
286
280
|
prefix?: string;
|
|
287
281
|
suffix?: string;
|
|
282
|
+
period?: {
|
|
283
|
+
start?: string;
|
|
284
|
+
end?: string;
|
|
285
|
+
};
|
|
288
286
|
}>, "many">;
|
|
289
287
|
telecom: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
290
288
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
@@ -301,17 +299,17 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
301
299
|
end?: string;
|
|
302
300
|
}>>>;
|
|
303
301
|
}, "strip", z.ZodTypeAny, {
|
|
304
|
-
value?: string;
|
|
305
|
-
system?: string;
|
|
306
302
|
use?: string;
|
|
303
|
+
system?: string;
|
|
304
|
+
value?: string;
|
|
307
305
|
period?: {
|
|
308
306
|
start?: string;
|
|
309
307
|
end?: string;
|
|
310
308
|
};
|
|
311
309
|
}, {
|
|
312
|
-
value?: string;
|
|
313
|
-
system?: string;
|
|
314
310
|
use?: string;
|
|
311
|
+
system?: string;
|
|
312
|
+
value?: string;
|
|
315
313
|
period?: {
|
|
316
314
|
start?: string;
|
|
317
315
|
end?: string;
|
|
@@ -323,12 +321,12 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
323
321
|
system: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
324
322
|
}, "strip", z.ZodTypeAny, {
|
|
325
323
|
code?: string;
|
|
326
|
-
system?: string;
|
|
327
324
|
display?: string;
|
|
325
|
+
system?: string;
|
|
328
326
|
}, {
|
|
329
327
|
code?: string;
|
|
330
|
-
system?: string;
|
|
331
328
|
display?: string;
|
|
329
|
+
system?: string;
|
|
332
330
|
}>;
|
|
333
331
|
birthDate: z.ZodUnion<[z.ZodString, z.ZodString]>;
|
|
334
332
|
address: z.ZodArray<z.ZodObject<{
|
|
@@ -350,26 +348,26 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
350
348
|
}>>>;
|
|
351
349
|
}, "strip", z.ZodTypeAny, {
|
|
352
350
|
use?: string;
|
|
353
|
-
period?: {
|
|
354
|
-
start?: string;
|
|
355
|
-
end?: string;
|
|
356
|
-
};
|
|
357
351
|
line?: string[];
|
|
358
352
|
city?: string;
|
|
359
353
|
state?: string;
|
|
360
354
|
zip?: string;
|
|
361
355
|
country?: string;
|
|
362
|
-
}, {
|
|
363
|
-
use?: string;
|
|
364
356
|
period?: {
|
|
365
357
|
start?: string;
|
|
366
358
|
end?: string;
|
|
367
359
|
};
|
|
360
|
+
}, {
|
|
361
|
+
use?: string;
|
|
368
362
|
line?: string[];
|
|
369
363
|
city?: string;
|
|
370
364
|
state?: string;
|
|
371
365
|
zip?: string;
|
|
372
366
|
country?: string;
|
|
367
|
+
period?: {
|
|
368
|
+
start?: string;
|
|
369
|
+
end?: string;
|
|
370
|
+
};
|
|
373
371
|
}>, "many">;
|
|
374
372
|
picture: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
|
|
375
373
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -385,21 +383,21 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
385
383
|
assigner?: string;
|
|
386
384
|
}[];
|
|
387
385
|
name?: {
|
|
388
|
-
text?: string;
|
|
389
386
|
use?: string;
|
|
390
|
-
|
|
391
|
-
start?: string;
|
|
392
|
-
end?: string;
|
|
393
|
-
};
|
|
387
|
+
text?: string;
|
|
394
388
|
family?: string[];
|
|
395
389
|
given?: string[];
|
|
396
390
|
prefix?: string;
|
|
397
391
|
suffix?: string;
|
|
392
|
+
period?: {
|
|
393
|
+
start?: string;
|
|
394
|
+
end?: string;
|
|
395
|
+
};
|
|
398
396
|
}[];
|
|
399
397
|
telecom?: {
|
|
400
|
-
value?: string;
|
|
401
|
-
system?: string;
|
|
402
398
|
use?: string;
|
|
399
|
+
system?: string;
|
|
400
|
+
value?: string;
|
|
403
401
|
period?: {
|
|
404
402
|
start?: string;
|
|
405
403
|
end?: string;
|
|
@@ -407,21 +405,21 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
407
405
|
}[];
|
|
408
406
|
gender?: {
|
|
409
407
|
code?: string;
|
|
410
|
-
system?: string;
|
|
411
408
|
display?: string;
|
|
409
|
+
system?: string;
|
|
412
410
|
};
|
|
413
411
|
birthDate?: string;
|
|
414
412
|
address?: {
|
|
415
413
|
use?: string;
|
|
416
|
-
period?: {
|
|
417
|
-
start?: string;
|
|
418
|
-
end?: string;
|
|
419
|
-
};
|
|
420
414
|
line?: string[];
|
|
421
415
|
city?: string;
|
|
422
416
|
state?: string;
|
|
423
417
|
zip?: string;
|
|
424
418
|
country?: string;
|
|
419
|
+
period?: {
|
|
420
|
+
start?: string;
|
|
421
|
+
end?: string;
|
|
422
|
+
};
|
|
425
423
|
}[];
|
|
426
424
|
picture?: any;
|
|
427
425
|
}, {
|
|
@@ -437,21 +435,21 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
437
435
|
assigner?: string;
|
|
438
436
|
}[];
|
|
439
437
|
name?: {
|
|
440
|
-
text?: string;
|
|
441
438
|
use?: string;
|
|
442
|
-
|
|
443
|
-
start?: string;
|
|
444
|
-
end?: string;
|
|
445
|
-
};
|
|
439
|
+
text?: string;
|
|
446
440
|
family?: string[];
|
|
447
441
|
given?: string[];
|
|
448
442
|
prefix?: string;
|
|
449
443
|
suffix?: string;
|
|
444
|
+
period?: {
|
|
445
|
+
start?: string;
|
|
446
|
+
end?: string;
|
|
447
|
+
};
|
|
450
448
|
}[];
|
|
451
449
|
telecom?: {
|
|
452
|
-
value?: string;
|
|
453
|
-
system?: string;
|
|
454
450
|
use?: string;
|
|
451
|
+
system?: string;
|
|
452
|
+
value?: string;
|
|
455
453
|
period?: {
|
|
456
454
|
start?: string;
|
|
457
455
|
end?: string;
|
|
@@ -459,21 +457,21 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
459
457
|
}[];
|
|
460
458
|
gender?: {
|
|
461
459
|
code?: string;
|
|
462
|
-
system?: string;
|
|
463
460
|
display?: string;
|
|
461
|
+
system?: string;
|
|
464
462
|
};
|
|
465
463
|
birthDate?: string;
|
|
466
464
|
address?: {
|
|
467
465
|
use?: string;
|
|
468
|
-
period?: {
|
|
469
|
-
start?: string;
|
|
470
|
-
end?: string;
|
|
471
|
-
};
|
|
472
466
|
line?: string[];
|
|
473
467
|
city?: string;
|
|
474
468
|
state?: string;
|
|
475
469
|
zip?: string;
|
|
476
470
|
country?: string;
|
|
471
|
+
period?: {
|
|
472
|
+
start?: string;
|
|
473
|
+
end?: string;
|
|
474
|
+
};
|
|
477
475
|
}[];
|
|
478
476
|
picture?: any;
|
|
479
477
|
}>;
|
|
@@ -483,140 +481,140 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
483
481
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
484
482
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
485
483
|
}, "strip", z.ZodTypeAny, {
|
|
486
|
-
type?: string;
|
|
487
484
|
href?: string;
|
|
488
485
|
templated?: boolean;
|
|
489
|
-
}, {
|
|
490
486
|
type?: string;
|
|
487
|
+
}, {
|
|
491
488
|
href?: string;
|
|
492
489
|
templated?: boolean;
|
|
490
|
+
type?: string;
|
|
493
491
|
}>;
|
|
494
492
|
networkLink: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
495
493
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
496
494
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
497
495
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
498
496
|
}, "strip", z.ZodTypeAny, {
|
|
499
|
-
type?: string;
|
|
500
497
|
href?: string;
|
|
501
498
|
templated?: boolean;
|
|
502
|
-
}, {
|
|
503
499
|
type?: string;
|
|
500
|
+
}, {
|
|
504
501
|
href?: string;
|
|
505
502
|
templated?: boolean;
|
|
503
|
+
type?: string;
|
|
506
504
|
}>>>;
|
|
507
505
|
person: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
508
506
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
509
507
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
510
508
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
511
509
|
}, "strip", z.ZodTypeAny, {
|
|
512
|
-
type?: string;
|
|
513
510
|
href?: string;
|
|
514
511
|
templated?: boolean;
|
|
515
|
-
}, {
|
|
516
512
|
type?: string;
|
|
513
|
+
}, {
|
|
517
514
|
href?: string;
|
|
518
515
|
templated?: boolean;
|
|
516
|
+
type?: string;
|
|
519
517
|
}>>>;
|
|
520
518
|
personMatch: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
521
519
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
522
520
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
523
521
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
524
522
|
}, "strip", z.ZodTypeAny, {
|
|
525
|
-
type?: string;
|
|
526
523
|
href?: string;
|
|
527
524
|
templated?: boolean;
|
|
528
|
-
}, {
|
|
529
525
|
type?: string;
|
|
526
|
+
}, {
|
|
530
527
|
href?: string;
|
|
531
528
|
templated?: boolean;
|
|
529
|
+
type?: string;
|
|
532
530
|
}>>>;
|
|
533
531
|
upgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
534
532
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
535
533
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
536
534
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
537
535
|
}, "strip", z.ZodTypeAny, {
|
|
538
|
-
type?: string;
|
|
539
536
|
href?: string;
|
|
540
537
|
templated?: boolean;
|
|
541
|
-
}, {
|
|
542
538
|
type?: string;
|
|
539
|
+
}, {
|
|
543
540
|
href?: string;
|
|
544
541
|
templated?: boolean;
|
|
542
|
+
type?: string;
|
|
545
543
|
}>>>;
|
|
546
544
|
downgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
547
545
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
548
546
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
549
547
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
550
548
|
}, "strip", z.ZodTypeAny, {
|
|
551
|
-
type?: string;
|
|
552
549
|
href?: string;
|
|
553
550
|
templated?: boolean;
|
|
554
|
-
}, {
|
|
555
551
|
type?: string;
|
|
552
|
+
}, {
|
|
556
553
|
href?: string;
|
|
557
554
|
templated?: boolean;
|
|
555
|
+
type?: string;
|
|
558
556
|
}>>>;
|
|
559
557
|
}, "strip", z.ZodTypeAny, {
|
|
560
558
|
self?: {
|
|
561
|
-
type?: string;
|
|
562
559
|
href?: string;
|
|
563
560
|
templated?: boolean;
|
|
564
|
-
};
|
|
565
|
-
upgrade?: {
|
|
566
561
|
type?: string;
|
|
567
|
-
href?: string;
|
|
568
|
-
templated?: boolean;
|
|
569
562
|
};
|
|
570
|
-
|
|
571
|
-
type?: string;
|
|
563
|
+
networkLink?: {
|
|
572
564
|
href?: string;
|
|
573
565
|
templated?: boolean;
|
|
566
|
+
type?: string;
|
|
574
567
|
};
|
|
575
568
|
person?: {
|
|
576
|
-
type?: string;
|
|
577
569
|
href?: string;
|
|
578
570
|
templated?: boolean;
|
|
579
|
-
};
|
|
580
|
-
networkLink?: {
|
|
581
571
|
type?: string;
|
|
582
|
-
href?: string;
|
|
583
|
-
templated?: boolean;
|
|
584
572
|
};
|
|
585
573
|
personMatch?: {
|
|
586
|
-
type?: string;
|
|
587
574
|
href?: string;
|
|
588
575
|
templated?: boolean;
|
|
589
|
-
};
|
|
590
|
-
}, {
|
|
591
|
-
self?: {
|
|
592
576
|
type?: string;
|
|
593
|
-
href?: string;
|
|
594
|
-
templated?: boolean;
|
|
595
577
|
};
|
|
596
578
|
upgrade?: {
|
|
597
|
-
type?: string;
|
|
598
579
|
href?: string;
|
|
599
580
|
templated?: boolean;
|
|
581
|
+
type?: string;
|
|
600
582
|
};
|
|
601
583
|
downgrade?: {
|
|
602
|
-
type?: string;
|
|
603
584
|
href?: string;
|
|
604
585
|
templated?: boolean;
|
|
605
|
-
};
|
|
606
|
-
person?: {
|
|
607
586
|
type?: string;
|
|
587
|
+
};
|
|
588
|
+
}, {
|
|
589
|
+
self?: {
|
|
608
590
|
href?: string;
|
|
609
591
|
templated?: boolean;
|
|
592
|
+
type?: string;
|
|
610
593
|
};
|
|
611
594
|
networkLink?: {
|
|
595
|
+
href?: string;
|
|
596
|
+
templated?: boolean;
|
|
612
597
|
type?: string;
|
|
598
|
+
};
|
|
599
|
+
person?: {
|
|
613
600
|
href?: string;
|
|
614
601
|
templated?: boolean;
|
|
602
|
+
type?: string;
|
|
615
603
|
};
|
|
616
604
|
personMatch?: {
|
|
605
|
+
href?: string;
|
|
606
|
+
templated?: boolean;
|
|
607
|
+
type?: string;
|
|
608
|
+
};
|
|
609
|
+
upgrade?: {
|
|
610
|
+
href?: string;
|
|
611
|
+
templated?: boolean;
|
|
617
612
|
type?: string;
|
|
613
|
+
};
|
|
614
|
+
downgrade?: {
|
|
618
615
|
href?: string;
|
|
619
616
|
templated?: boolean;
|
|
617
|
+
type?: string;
|
|
620
618
|
};
|
|
621
619
|
}>>>;
|
|
622
620
|
facilities: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -641,59 +639,60 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
641
639
|
}>>>;
|
|
642
640
|
}, "strip", z.ZodTypeAny, {
|
|
643
641
|
use?: string;
|
|
644
|
-
period?: {
|
|
645
|
-
start?: string;
|
|
646
|
-
end?: string;
|
|
647
|
-
};
|
|
648
642
|
line?: string[];
|
|
649
643
|
city?: string;
|
|
650
644
|
state?: string;
|
|
651
645
|
zip?: string;
|
|
652
646
|
country?: string;
|
|
653
|
-
}, {
|
|
654
|
-
use?: string;
|
|
655
647
|
period?: {
|
|
656
648
|
start?: string;
|
|
657
649
|
end?: string;
|
|
658
650
|
};
|
|
651
|
+
}, {
|
|
652
|
+
use?: string;
|
|
659
653
|
line?: string[];
|
|
660
654
|
city?: string;
|
|
661
655
|
state?: string;
|
|
662
656
|
zip?: string;
|
|
663
657
|
country?: string;
|
|
658
|
+
period?: {
|
|
659
|
+
start?: string;
|
|
660
|
+
end?: string;
|
|
661
|
+
};
|
|
664
662
|
}>>>;
|
|
665
663
|
}, "strip", z.ZodTypeAny, {
|
|
664
|
+
id?: string;
|
|
666
665
|
name?: string;
|
|
667
666
|
address?: {
|
|
668
667
|
use?: string;
|
|
669
|
-
period?: {
|
|
670
|
-
start?: string;
|
|
671
|
-
end?: string;
|
|
672
|
-
};
|
|
673
668
|
line?: string[];
|
|
674
669
|
city?: string;
|
|
675
670
|
state?: string;
|
|
676
671
|
zip?: string;
|
|
677
672
|
country?: string;
|
|
678
|
-
};
|
|
679
|
-
id?: string;
|
|
680
|
-
}, {
|
|
681
|
-
name?: string;
|
|
682
|
-
address?: {
|
|
683
|
-
use?: string;
|
|
684
673
|
period?: {
|
|
685
674
|
start?: string;
|
|
686
675
|
end?: string;
|
|
687
676
|
};
|
|
677
|
+
};
|
|
678
|
+
}, {
|
|
679
|
+
id?: string;
|
|
680
|
+
name?: string;
|
|
681
|
+
address?: {
|
|
682
|
+
use?: string;
|
|
688
683
|
line?: string[];
|
|
689
684
|
city?: string;
|
|
690
685
|
state?: string;
|
|
691
686
|
zip?: string;
|
|
692
687
|
country?: string;
|
|
688
|
+
period?: {
|
|
689
|
+
start?: string;
|
|
690
|
+
end?: string;
|
|
691
|
+
};
|
|
693
692
|
};
|
|
694
|
-
id?: string;
|
|
695
693
|
}>, "many">>>;
|
|
696
694
|
}, "strip", z.ZodTypeAny, {
|
|
695
|
+
active?: boolean;
|
|
697
696
|
identifier?: {
|
|
698
697
|
system?: string;
|
|
699
698
|
key?: string;
|
|
@@ -705,37 +704,10 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
705
704
|
};
|
|
706
705
|
assigner?: string;
|
|
707
706
|
}[];
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
templated?: boolean;
|
|
713
|
-
};
|
|
714
|
-
upgrade?: {
|
|
715
|
-
type?: string;
|
|
716
|
-
href?: string;
|
|
717
|
-
templated?: boolean;
|
|
718
|
-
};
|
|
719
|
-
downgrade?: {
|
|
720
|
-
type?: string;
|
|
721
|
-
href?: string;
|
|
722
|
-
templated?: boolean;
|
|
723
|
-
};
|
|
724
|
-
person?: {
|
|
725
|
-
type?: string;
|
|
726
|
-
href?: string;
|
|
727
|
-
templated?: boolean;
|
|
728
|
-
};
|
|
729
|
-
networkLink?: {
|
|
730
|
-
type?: string;
|
|
731
|
-
href?: string;
|
|
732
|
-
templated?: boolean;
|
|
733
|
-
};
|
|
734
|
-
personMatch?: {
|
|
735
|
-
type?: string;
|
|
736
|
-
href?: string;
|
|
737
|
-
templated?: boolean;
|
|
738
|
-
};
|
|
707
|
+
provider?: {
|
|
708
|
+
type?: string;
|
|
709
|
+
reference?: string;
|
|
710
|
+
display?: string;
|
|
739
711
|
};
|
|
740
712
|
details?: {
|
|
741
713
|
identifier?: {
|
|
@@ -750,21 +722,21 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
750
722
|
assigner?: string;
|
|
751
723
|
}[];
|
|
752
724
|
name?: {
|
|
753
|
-
text?: string;
|
|
754
725
|
use?: string;
|
|
755
|
-
|
|
756
|
-
start?: string;
|
|
757
|
-
end?: string;
|
|
758
|
-
};
|
|
726
|
+
text?: string;
|
|
759
727
|
family?: string[];
|
|
760
728
|
given?: string[];
|
|
761
729
|
prefix?: string;
|
|
762
730
|
suffix?: string;
|
|
731
|
+
period?: {
|
|
732
|
+
start?: string;
|
|
733
|
+
end?: string;
|
|
734
|
+
};
|
|
763
735
|
}[];
|
|
764
736
|
telecom?: {
|
|
765
|
-
value?: string;
|
|
766
|
-
system?: string;
|
|
767
737
|
use?: string;
|
|
738
|
+
system?: string;
|
|
739
|
+
value?: string;
|
|
768
740
|
period?: {
|
|
769
741
|
start?: string;
|
|
770
742
|
end?: string;
|
|
@@ -772,47 +744,74 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
772
744
|
}[];
|
|
773
745
|
gender?: {
|
|
774
746
|
code?: string;
|
|
775
|
-
system?: string;
|
|
776
747
|
display?: string;
|
|
748
|
+
system?: string;
|
|
777
749
|
};
|
|
778
750
|
birthDate?: string;
|
|
779
751
|
address?: {
|
|
780
752
|
use?: string;
|
|
781
|
-
period?: {
|
|
782
|
-
start?: string;
|
|
783
|
-
end?: string;
|
|
784
|
-
};
|
|
785
753
|
line?: string[];
|
|
786
754
|
city?: string;
|
|
787
755
|
state?: string;
|
|
788
756
|
zip?: string;
|
|
789
757
|
country?: string;
|
|
758
|
+
period?: {
|
|
759
|
+
start?: string;
|
|
760
|
+
end?: string;
|
|
761
|
+
};
|
|
790
762
|
}[];
|
|
791
763
|
picture?: any;
|
|
792
764
|
};
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
765
|
+
_links?: {
|
|
766
|
+
self?: {
|
|
767
|
+
href?: string;
|
|
768
|
+
templated?: boolean;
|
|
769
|
+
type?: string;
|
|
770
|
+
};
|
|
771
|
+
networkLink?: {
|
|
772
|
+
href?: string;
|
|
773
|
+
templated?: boolean;
|
|
774
|
+
type?: string;
|
|
775
|
+
};
|
|
776
|
+
person?: {
|
|
777
|
+
href?: string;
|
|
778
|
+
templated?: boolean;
|
|
779
|
+
type?: string;
|
|
780
|
+
};
|
|
781
|
+
personMatch?: {
|
|
782
|
+
href?: string;
|
|
783
|
+
templated?: boolean;
|
|
784
|
+
type?: string;
|
|
785
|
+
};
|
|
786
|
+
upgrade?: {
|
|
787
|
+
href?: string;
|
|
788
|
+
templated?: boolean;
|
|
789
|
+
type?: string;
|
|
790
|
+
};
|
|
791
|
+
downgrade?: {
|
|
792
|
+
href?: string;
|
|
793
|
+
templated?: boolean;
|
|
794
|
+
type?: string;
|
|
795
|
+
};
|
|
798
796
|
};
|
|
799
797
|
facilities?: {
|
|
798
|
+
id?: string;
|
|
800
799
|
name?: string;
|
|
801
800
|
address?: {
|
|
802
801
|
use?: string;
|
|
803
|
-
period?: {
|
|
804
|
-
start?: string;
|
|
805
|
-
end?: string;
|
|
806
|
-
};
|
|
807
802
|
line?: string[];
|
|
808
803
|
city?: string;
|
|
809
804
|
state?: string;
|
|
810
805
|
zip?: string;
|
|
811
806
|
country?: string;
|
|
807
|
+
period?: {
|
|
808
|
+
start?: string;
|
|
809
|
+
end?: string;
|
|
810
|
+
};
|
|
812
811
|
};
|
|
813
|
-
id?: string;
|
|
814
812
|
}[];
|
|
815
813
|
}, {
|
|
814
|
+
active?: boolean;
|
|
816
815
|
identifier?: {
|
|
817
816
|
system?: string;
|
|
818
817
|
key?: string;
|
|
@@ -824,37 +823,10 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
824
823
|
};
|
|
825
824
|
assigner?: string;
|
|
826
825
|
}[];
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
templated?: boolean;
|
|
832
|
-
};
|
|
833
|
-
upgrade?: {
|
|
834
|
-
type?: string;
|
|
835
|
-
href?: string;
|
|
836
|
-
templated?: boolean;
|
|
837
|
-
};
|
|
838
|
-
downgrade?: {
|
|
839
|
-
type?: string;
|
|
840
|
-
href?: string;
|
|
841
|
-
templated?: boolean;
|
|
842
|
-
};
|
|
843
|
-
person?: {
|
|
844
|
-
type?: string;
|
|
845
|
-
href?: string;
|
|
846
|
-
templated?: boolean;
|
|
847
|
-
};
|
|
848
|
-
networkLink?: {
|
|
849
|
-
type?: string;
|
|
850
|
-
href?: string;
|
|
851
|
-
templated?: boolean;
|
|
852
|
-
};
|
|
853
|
-
personMatch?: {
|
|
854
|
-
type?: string;
|
|
855
|
-
href?: string;
|
|
856
|
-
templated?: boolean;
|
|
857
|
-
};
|
|
826
|
+
provider?: {
|
|
827
|
+
type?: string;
|
|
828
|
+
reference?: string;
|
|
829
|
+
display?: string;
|
|
858
830
|
};
|
|
859
831
|
details?: {
|
|
860
832
|
identifier?: {
|
|
@@ -869,21 +841,21 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
869
841
|
assigner?: string;
|
|
870
842
|
}[];
|
|
871
843
|
name?: {
|
|
872
|
-
text?: string;
|
|
873
844
|
use?: string;
|
|
874
|
-
|
|
875
|
-
start?: string;
|
|
876
|
-
end?: string;
|
|
877
|
-
};
|
|
845
|
+
text?: string;
|
|
878
846
|
family?: string[];
|
|
879
847
|
given?: string[];
|
|
880
848
|
prefix?: string;
|
|
881
849
|
suffix?: string;
|
|
850
|
+
period?: {
|
|
851
|
+
start?: string;
|
|
852
|
+
end?: string;
|
|
853
|
+
};
|
|
882
854
|
}[];
|
|
883
855
|
telecom?: {
|
|
884
|
-
value?: string;
|
|
885
|
-
system?: string;
|
|
886
856
|
use?: string;
|
|
857
|
+
system?: string;
|
|
858
|
+
value?: string;
|
|
887
859
|
period?: {
|
|
888
860
|
start?: string;
|
|
889
861
|
end?: string;
|
|
@@ -891,45 +863,71 @@ export declare const patientSchema: z.ZodObject<{
|
|
|
891
863
|
}[];
|
|
892
864
|
gender?: {
|
|
893
865
|
code?: string;
|
|
894
|
-
system?: string;
|
|
895
866
|
display?: string;
|
|
867
|
+
system?: string;
|
|
896
868
|
};
|
|
897
869
|
birthDate?: string;
|
|
898
870
|
address?: {
|
|
899
871
|
use?: string;
|
|
900
|
-
period?: {
|
|
901
|
-
start?: string;
|
|
902
|
-
end?: string;
|
|
903
|
-
};
|
|
904
872
|
line?: string[];
|
|
905
873
|
city?: string;
|
|
906
874
|
state?: string;
|
|
907
875
|
zip?: string;
|
|
908
876
|
country?: string;
|
|
877
|
+
period?: {
|
|
878
|
+
start?: string;
|
|
879
|
+
end?: string;
|
|
880
|
+
};
|
|
909
881
|
}[];
|
|
910
882
|
picture?: any;
|
|
911
883
|
};
|
|
912
|
-
|
|
913
|
-
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
884
|
+
_links?: {
|
|
885
|
+
self?: {
|
|
886
|
+
href?: string;
|
|
887
|
+
templated?: boolean;
|
|
888
|
+
type?: string;
|
|
889
|
+
};
|
|
890
|
+
networkLink?: {
|
|
891
|
+
href?: string;
|
|
892
|
+
templated?: boolean;
|
|
893
|
+
type?: string;
|
|
894
|
+
};
|
|
895
|
+
person?: {
|
|
896
|
+
href?: string;
|
|
897
|
+
templated?: boolean;
|
|
898
|
+
type?: string;
|
|
899
|
+
};
|
|
900
|
+
personMatch?: {
|
|
901
|
+
href?: string;
|
|
902
|
+
templated?: boolean;
|
|
903
|
+
type?: string;
|
|
904
|
+
};
|
|
905
|
+
upgrade?: {
|
|
906
|
+
href?: string;
|
|
907
|
+
templated?: boolean;
|
|
908
|
+
type?: string;
|
|
909
|
+
};
|
|
910
|
+
downgrade?: {
|
|
911
|
+
href?: string;
|
|
912
|
+
templated?: boolean;
|
|
913
|
+
type?: string;
|
|
914
|
+
};
|
|
917
915
|
};
|
|
918
916
|
facilities?: {
|
|
917
|
+
id?: string;
|
|
919
918
|
name?: string;
|
|
920
919
|
address?: {
|
|
921
920
|
use?: string;
|
|
922
|
-
period?: {
|
|
923
|
-
start?: string;
|
|
924
|
-
end?: string;
|
|
925
|
-
};
|
|
926
921
|
line?: string[];
|
|
927
922
|
city?: string;
|
|
928
923
|
state?: string;
|
|
929
924
|
zip?: string;
|
|
930
925
|
country?: string;
|
|
926
|
+
period?: {
|
|
927
|
+
start?: string;
|
|
928
|
+
end?: string;
|
|
929
|
+
};
|
|
931
930
|
};
|
|
932
|
-
id?: string;
|
|
933
931
|
}[];
|
|
934
932
|
}>;
|
|
935
933
|
export type Patient = z.infer<typeof patientSchema>;
|
|
@@ -938,10 +936,9 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
938
936
|
_embedded: z.ZodObject<{
|
|
939
937
|
patient: z.ZodArray<z.ZodObject<{
|
|
940
938
|
active: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
941
|
-
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<
|
|
939
|
+
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
942
940
|
system: z.ZodString;
|
|
943
941
|
key: z.ZodString;
|
|
944
|
-
}, {
|
|
945
942
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
946
943
|
label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
947
944
|
period: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
@@ -955,7 +952,7 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
955
952
|
end?: string;
|
|
956
953
|
}>>>;
|
|
957
954
|
assigner: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
958
|
-
}
|
|
955
|
+
}, "strip", z.ZodTypeAny, {
|
|
959
956
|
system?: string;
|
|
960
957
|
key?: string;
|
|
961
958
|
use?: string;
|
|
@@ -982,18 +979,17 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
982
979
|
display: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
983
980
|
}, "strip", z.ZodTypeAny, {
|
|
984
981
|
type?: string;
|
|
985
|
-
display?: string;
|
|
986
982
|
reference?: string;
|
|
983
|
+
display?: string;
|
|
987
984
|
}, {
|
|
988
985
|
type?: string;
|
|
989
|
-
display?: string;
|
|
990
986
|
reference?: string;
|
|
987
|
+
display?: string;
|
|
991
988
|
}>>>;
|
|
992
989
|
details: z.ZodObject<{
|
|
993
|
-
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<
|
|
990
|
+
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
994
991
|
system: z.ZodString;
|
|
995
992
|
key: z.ZodString;
|
|
996
|
-
}, {
|
|
997
993
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
998
994
|
label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
999
995
|
period: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
@@ -1007,7 +1003,7 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1007
1003
|
end?: string;
|
|
1008
1004
|
}>>>;
|
|
1009
1005
|
assigner: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1010
|
-
}
|
|
1006
|
+
}, "strip", z.ZodTypeAny, {
|
|
1011
1007
|
system?: string;
|
|
1012
1008
|
key?: string;
|
|
1013
1009
|
use?: string;
|
|
@@ -1046,27 +1042,27 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1046
1042
|
end?: string;
|
|
1047
1043
|
}>>>;
|
|
1048
1044
|
}, "strip", z.ZodTypeAny, {
|
|
1049
|
-
text?: string;
|
|
1050
1045
|
use?: string;
|
|
1051
|
-
|
|
1052
|
-
start?: string;
|
|
1053
|
-
end?: string;
|
|
1054
|
-
};
|
|
1046
|
+
text?: string;
|
|
1055
1047
|
family?: string[];
|
|
1056
1048
|
given?: string[];
|
|
1057
1049
|
prefix?: string;
|
|
1058
1050
|
suffix?: string;
|
|
1059
|
-
}, {
|
|
1060
|
-
text?: string;
|
|
1061
|
-
use?: string;
|
|
1062
1051
|
period?: {
|
|
1063
1052
|
start?: string;
|
|
1064
1053
|
end?: string;
|
|
1065
1054
|
};
|
|
1055
|
+
}, {
|
|
1056
|
+
use?: string;
|
|
1057
|
+
text?: string;
|
|
1066
1058
|
family?: string[];
|
|
1067
1059
|
given?: string[];
|
|
1068
1060
|
prefix?: string;
|
|
1069
1061
|
suffix?: string;
|
|
1062
|
+
period?: {
|
|
1063
|
+
start?: string;
|
|
1064
|
+
end?: string;
|
|
1065
|
+
};
|
|
1070
1066
|
}>, "many">;
|
|
1071
1067
|
telecom: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1072
1068
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
@@ -1083,17 +1079,17 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1083
1079
|
end?: string;
|
|
1084
1080
|
}>>>;
|
|
1085
1081
|
}, "strip", z.ZodTypeAny, {
|
|
1086
|
-
value?: string;
|
|
1087
|
-
system?: string;
|
|
1088
1082
|
use?: string;
|
|
1083
|
+
system?: string;
|
|
1084
|
+
value?: string;
|
|
1089
1085
|
period?: {
|
|
1090
1086
|
start?: string;
|
|
1091
1087
|
end?: string;
|
|
1092
1088
|
};
|
|
1093
1089
|
}, {
|
|
1094
|
-
value?: string;
|
|
1095
|
-
system?: string;
|
|
1096
1090
|
use?: string;
|
|
1091
|
+
system?: string;
|
|
1092
|
+
value?: string;
|
|
1097
1093
|
period?: {
|
|
1098
1094
|
start?: string;
|
|
1099
1095
|
end?: string;
|
|
@@ -1105,12 +1101,12 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1105
1101
|
system: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1106
1102
|
}, "strip", z.ZodTypeAny, {
|
|
1107
1103
|
code?: string;
|
|
1108
|
-
system?: string;
|
|
1109
1104
|
display?: string;
|
|
1105
|
+
system?: string;
|
|
1110
1106
|
}, {
|
|
1111
1107
|
code?: string;
|
|
1112
|
-
system?: string;
|
|
1113
1108
|
display?: string;
|
|
1109
|
+
system?: string;
|
|
1114
1110
|
}>;
|
|
1115
1111
|
birthDate: z.ZodUnion<[z.ZodString, z.ZodString]>;
|
|
1116
1112
|
address: z.ZodArray<z.ZodObject<{
|
|
@@ -1132,26 +1128,26 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1132
1128
|
}>>>;
|
|
1133
1129
|
}, "strip", z.ZodTypeAny, {
|
|
1134
1130
|
use?: string;
|
|
1135
|
-
period?: {
|
|
1136
|
-
start?: string;
|
|
1137
|
-
end?: string;
|
|
1138
|
-
};
|
|
1139
1131
|
line?: string[];
|
|
1140
1132
|
city?: string;
|
|
1141
1133
|
state?: string;
|
|
1142
1134
|
zip?: string;
|
|
1143
1135
|
country?: string;
|
|
1144
|
-
}, {
|
|
1145
|
-
use?: string;
|
|
1146
1136
|
period?: {
|
|
1147
1137
|
start?: string;
|
|
1148
1138
|
end?: string;
|
|
1149
1139
|
};
|
|
1140
|
+
}, {
|
|
1141
|
+
use?: string;
|
|
1150
1142
|
line?: string[];
|
|
1151
1143
|
city?: string;
|
|
1152
1144
|
state?: string;
|
|
1153
1145
|
zip?: string;
|
|
1154
1146
|
country?: string;
|
|
1147
|
+
period?: {
|
|
1148
|
+
start?: string;
|
|
1149
|
+
end?: string;
|
|
1150
|
+
};
|
|
1155
1151
|
}>, "many">;
|
|
1156
1152
|
picture: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
|
|
1157
1153
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -1167,21 +1163,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1167
1163
|
assigner?: string;
|
|
1168
1164
|
}[];
|
|
1169
1165
|
name?: {
|
|
1170
|
-
text?: string;
|
|
1171
1166
|
use?: string;
|
|
1172
|
-
|
|
1173
|
-
start?: string;
|
|
1174
|
-
end?: string;
|
|
1175
|
-
};
|
|
1167
|
+
text?: string;
|
|
1176
1168
|
family?: string[];
|
|
1177
1169
|
given?: string[];
|
|
1178
1170
|
prefix?: string;
|
|
1179
1171
|
suffix?: string;
|
|
1172
|
+
period?: {
|
|
1173
|
+
start?: string;
|
|
1174
|
+
end?: string;
|
|
1175
|
+
};
|
|
1180
1176
|
}[];
|
|
1181
1177
|
telecom?: {
|
|
1182
|
-
value?: string;
|
|
1183
|
-
system?: string;
|
|
1184
1178
|
use?: string;
|
|
1179
|
+
system?: string;
|
|
1180
|
+
value?: string;
|
|
1185
1181
|
period?: {
|
|
1186
1182
|
start?: string;
|
|
1187
1183
|
end?: string;
|
|
@@ -1189,21 +1185,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1189
1185
|
}[];
|
|
1190
1186
|
gender?: {
|
|
1191
1187
|
code?: string;
|
|
1192
|
-
system?: string;
|
|
1193
1188
|
display?: string;
|
|
1189
|
+
system?: string;
|
|
1194
1190
|
};
|
|
1195
1191
|
birthDate?: string;
|
|
1196
1192
|
address?: {
|
|
1197
1193
|
use?: string;
|
|
1198
|
-
period?: {
|
|
1199
|
-
start?: string;
|
|
1200
|
-
end?: string;
|
|
1201
|
-
};
|
|
1202
1194
|
line?: string[];
|
|
1203
1195
|
city?: string;
|
|
1204
1196
|
state?: string;
|
|
1205
1197
|
zip?: string;
|
|
1206
1198
|
country?: string;
|
|
1199
|
+
period?: {
|
|
1200
|
+
start?: string;
|
|
1201
|
+
end?: string;
|
|
1202
|
+
};
|
|
1207
1203
|
}[];
|
|
1208
1204
|
picture?: any;
|
|
1209
1205
|
}, {
|
|
@@ -1219,21 +1215,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1219
1215
|
assigner?: string;
|
|
1220
1216
|
}[];
|
|
1221
1217
|
name?: {
|
|
1222
|
-
text?: string;
|
|
1223
1218
|
use?: string;
|
|
1224
|
-
|
|
1225
|
-
start?: string;
|
|
1226
|
-
end?: string;
|
|
1227
|
-
};
|
|
1219
|
+
text?: string;
|
|
1228
1220
|
family?: string[];
|
|
1229
1221
|
given?: string[];
|
|
1230
1222
|
prefix?: string;
|
|
1231
1223
|
suffix?: string;
|
|
1224
|
+
period?: {
|
|
1225
|
+
start?: string;
|
|
1226
|
+
end?: string;
|
|
1227
|
+
};
|
|
1232
1228
|
}[];
|
|
1233
1229
|
telecom?: {
|
|
1234
|
-
value?: string;
|
|
1235
|
-
system?: string;
|
|
1236
1230
|
use?: string;
|
|
1231
|
+
system?: string;
|
|
1232
|
+
value?: string;
|
|
1237
1233
|
period?: {
|
|
1238
1234
|
start?: string;
|
|
1239
1235
|
end?: string;
|
|
@@ -1241,21 +1237,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1241
1237
|
}[];
|
|
1242
1238
|
gender?: {
|
|
1243
1239
|
code?: string;
|
|
1244
|
-
system?: string;
|
|
1245
1240
|
display?: string;
|
|
1241
|
+
system?: string;
|
|
1246
1242
|
};
|
|
1247
1243
|
birthDate?: string;
|
|
1248
1244
|
address?: {
|
|
1249
1245
|
use?: string;
|
|
1250
|
-
period?: {
|
|
1251
|
-
start?: string;
|
|
1252
|
-
end?: string;
|
|
1253
|
-
};
|
|
1254
1246
|
line?: string[];
|
|
1255
1247
|
city?: string;
|
|
1256
1248
|
state?: string;
|
|
1257
1249
|
zip?: string;
|
|
1258
1250
|
country?: string;
|
|
1251
|
+
period?: {
|
|
1252
|
+
start?: string;
|
|
1253
|
+
end?: string;
|
|
1254
|
+
};
|
|
1259
1255
|
}[];
|
|
1260
1256
|
picture?: any;
|
|
1261
1257
|
}>;
|
|
@@ -1265,140 +1261,140 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1265
1261
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1266
1262
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1267
1263
|
}, "strip", z.ZodTypeAny, {
|
|
1268
|
-
type?: string;
|
|
1269
1264
|
href?: string;
|
|
1270
1265
|
templated?: boolean;
|
|
1271
|
-
}, {
|
|
1272
1266
|
type?: string;
|
|
1267
|
+
}, {
|
|
1273
1268
|
href?: string;
|
|
1274
1269
|
templated?: boolean;
|
|
1270
|
+
type?: string;
|
|
1275
1271
|
}>;
|
|
1276
1272
|
networkLink: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
1277
1273
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1278
1274
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1279
1275
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1280
1276
|
}, "strip", z.ZodTypeAny, {
|
|
1281
|
-
type?: string;
|
|
1282
1277
|
href?: string;
|
|
1283
1278
|
templated?: boolean;
|
|
1284
|
-
}, {
|
|
1285
1279
|
type?: string;
|
|
1280
|
+
}, {
|
|
1286
1281
|
href?: string;
|
|
1287
1282
|
templated?: boolean;
|
|
1283
|
+
type?: string;
|
|
1288
1284
|
}>>>;
|
|
1289
1285
|
person: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
1290
1286
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1291
1287
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1292
1288
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1293
1289
|
}, "strip", z.ZodTypeAny, {
|
|
1294
|
-
type?: string;
|
|
1295
1290
|
href?: string;
|
|
1296
1291
|
templated?: boolean;
|
|
1297
|
-
}, {
|
|
1298
1292
|
type?: string;
|
|
1293
|
+
}, {
|
|
1299
1294
|
href?: string;
|
|
1300
1295
|
templated?: boolean;
|
|
1296
|
+
type?: string;
|
|
1301
1297
|
}>>>;
|
|
1302
1298
|
personMatch: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
1303
1299
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1304
1300
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1305
1301
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1306
1302
|
}, "strip", z.ZodTypeAny, {
|
|
1307
|
-
type?: string;
|
|
1308
1303
|
href?: string;
|
|
1309
1304
|
templated?: boolean;
|
|
1310
|
-
}, {
|
|
1311
1305
|
type?: string;
|
|
1306
|
+
}, {
|
|
1312
1307
|
href?: string;
|
|
1313
1308
|
templated?: boolean;
|
|
1309
|
+
type?: string;
|
|
1314
1310
|
}>>>;
|
|
1315
1311
|
upgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
1316
1312
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1317
1313
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1318
1314
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1319
1315
|
}, "strip", z.ZodTypeAny, {
|
|
1320
|
-
type?: string;
|
|
1321
1316
|
href?: string;
|
|
1322
1317
|
templated?: boolean;
|
|
1323
|
-
}, {
|
|
1324
1318
|
type?: string;
|
|
1319
|
+
}, {
|
|
1325
1320
|
href?: string;
|
|
1326
1321
|
templated?: boolean;
|
|
1322
|
+
type?: string;
|
|
1327
1323
|
}>>>;
|
|
1328
1324
|
downgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
1329
1325
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1330
1326
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1331
1327
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1332
1328
|
}, "strip", z.ZodTypeAny, {
|
|
1333
|
-
type?: string;
|
|
1334
1329
|
href?: string;
|
|
1335
1330
|
templated?: boolean;
|
|
1336
|
-
}, {
|
|
1337
1331
|
type?: string;
|
|
1332
|
+
}, {
|
|
1338
1333
|
href?: string;
|
|
1339
1334
|
templated?: boolean;
|
|
1335
|
+
type?: string;
|
|
1340
1336
|
}>>>;
|
|
1341
1337
|
}, "strip", z.ZodTypeAny, {
|
|
1342
1338
|
self?: {
|
|
1343
|
-
type?: string;
|
|
1344
1339
|
href?: string;
|
|
1345
1340
|
templated?: boolean;
|
|
1346
|
-
};
|
|
1347
|
-
upgrade?: {
|
|
1348
1341
|
type?: string;
|
|
1349
|
-
href?: string;
|
|
1350
|
-
templated?: boolean;
|
|
1351
1342
|
};
|
|
1352
|
-
|
|
1353
|
-
type?: string;
|
|
1343
|
+
networkLink?: {
|
|
1354
1344
|
href?: string;
|
|
1355
1345
|
templated?: boolean;
|
|
1346
|
+
type?: string;
|
|
1356
1347
|
};
|
|
1357
1348
|
person?: {
|
|
1358
|
-
type?: string;
|
|
1359
1349
|
href?: string;
|
|
1360
1350
|
templated?: boolean;
|
|
1361
|
-
};
|
|
1362
|
-
networkLink?: {
|
|
1363
1351
|
type?: string;
|
|
1364
|
-
href?: string;
|
|
1365
|
-
templated?: boolean;
|
|
1366
1352
|
};
|
|
1367
1353
|
personMatch?: {
|
|
1368
|
-
type?: string;
|
|
1369
1354
|
href?: string;
|
|
1370
1355
|
templated?: boolean;
|
|
1371
|
-
};
|
|
1372
|
-
}, {
|
|
1373
|
-
self?: {
|
|
1374
1356
|
type?: string;
|
|
1375
|
-
href?: string;
|
|
1376
|
-
templated?: boolean;
|
|
1377
1357
|
};
|
|
1378
1358
|
upgrade?: {
|
|
1379
|
-
type?: string;
|
|
1380
1359
|
href?: string;
|
|
1381
1360
|
templated?: boolean;
|
|
1361
|
+
type?: string;
|
|
1382
1362
|
};
|
|
1383
1363
|
downgrade?: {
|
|
1384
|
-
type?: string;
|
|
1385
1364
|
href?: string;
|
|
1386
1365
|
templated?: boolean;
|
|
1387
|
-
};
|
|
1388
|
-
person?: {
|
|
1389
1366
|
type?: string;
|
|
1367
|
+
};
|
|
1368
|
+
}, {
|
|
1369
|
+
self?: {
|
|
1390
1370
|
href?: string;
|
|
1391
1371
|
templated?: boolean;
|
|
1372
|
+
type?: string;
|
|
1392
1373
|
};
|
|
1393
1374
|
networkLink?: {
|
|
1375
|
+
href?: string;
|
|
1376
|
+
templated?: boolean;
|
|
1394
1377
|
type?: string;
|
|
1378
|
+
};
|
|
1379
|
+
person?: {
|
|
1395
1380
|
href?: string;
|
|
1396
1381
|
templated?: boolean;
|
|
1382
|
+
type?: string;
|
|
1397
1383
|
};
|
|
1398
1384
|
personMatch?: {
|
|
1385
|
+
href?: string;
|
|
1386
|
+
templated?: boolean;
|
|
1387
|
+
type?: string;
|
|
1388
|
+
};
|
|
1389
|
+
upgrade?: {
|
|
1390
|
+
href?: string;
|
|
1391
|
+
templated?: boolean;
|
|
1399
1392
|
type?: string;
|
|
1393
|
+
};
|
|
1394
|
+
downgrade?: {
|
|
1400
1395
|
href?: string;
|
|
1401
1396
|
templated?: boolean;
|
|
1397
|
+
type?: string;
|
|
1402
1398
|
};
|
|
1403
1399
|
}>>>;
|
|
1404
1400
|
facilities: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -1423,59 +1419,60 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1423
1419
|
}>>>;
|
|
1424
1420
|
}, "strip", z.ZodTypeAny, {
|
|
1425
1421
|
use?: string;
|
|
1426
|
-
period?: {
|
|
1427
|
-
start?: string;
|
|
1428
|
-
end?: string;
|
|
1429
|
-
};
|
|
1430
1422
|
line?: string[];
|
|
1431
1423
|
city?: string;
|
|
1432
1424
|
state?: string;
|
|
1433
1425
|
zip?: string;
|
|
1434
1426
|
country?: string;
|
|
1435
|
-
}, {
|
|
1436
|
-
use?: string;
|
|
1437
1427
|
period?: {
|
|
1438
1428
|
start?: string;
|
|
1439
1429
|
end?: string;
|
|
1440
1430
|
};
|
|
1431
|
+
}, {
|
|
1432
|
+
use?: string;
|
|
1441
1433
|
line?: string[];
|
|
1442
1434
|
city?: string;
|
|
1443
1435
|
state?: string;
|
|
1444
1436
|
zip?: string;
|
|
1445
1437
|
country?: string;
|
|
1438
|
+
period?: {
|
|
1439
|
+
start?: string;
|
|
1440
|
+
end?: string;
|
|
1441
|
+
};
|
|
1446
1442
|
}>>>;
|
|
1447
1443
|
}, "strip", z.ZodTypeAny, {
|
|
1444
|
+
id?: string;
|
|
1448
1445
|
name?: string;
|
|
1449
1446
|
address?: {
|
|
1450
1447
|
use?: string;
|
|
1451
|
-
period?: {
|
|
1452
|
-
start?: string;
|
|
1453
|
-
end?: string;
|
|
1454
|
-
};
|
|
1455
1448
|
line?: string[];
|
|
1456
1449
|
city?: string;
|
|
1457
1450
|
state?: string;
|
|
1458
1451
|
zip?: string;
|
|
1459
1452
|
country?: string;
|
|
1453
|
+
period?: {
|
|
1454
|
+
start?: string;
|
|
1455
|
+
end?: string;
|
|
1456
|
+
};
|
|
1460
1457
|
};
|
|
1461
|
-
id?: string;
|
|
1462
1458
|
}, {
|
|
1459
|
+
id?: string;
|
|
1463
1460
|
name?: string;
|
|
1464
1461
|
address?: {
|
|
1465
1462
|
use?: string;
|
|
1466
|
-
period?: {
|
|
1467
|
-
start?: string;
|
|
1468
|
-
end?: string;
|
|
1469
|
-
};
|
|
1470
1463
|
line?: string[];
|
|
1471
1464
|
city?: string;
|
|
1472
1465
|
state?: string;
|
|
1473
1466
|
zip?: string;
|
|
1474
1467
|
country?: string;
|
|
1468
|
+
period?: {
|
|
1469
|
+
start?: string;
|
|
1470
|
+
end?: string;
|
|
1471
|
+
};
|
|
1475
1472
|
};
|
|
1476
|
-
id?: string;
|
|
1477
1473
|
}>, "many">>>;
|
|
1478
1474
|
}, "strip", z.ZodTypeAny, {
|
|
1475
|
+
active?: boolean;
|
|
1479
1476
|
identifier?: {
|
|
1480
1477
|
system?: string;
|
|
1481
1478
|
key?: string;
|
|
@@ -1487,37 +1484,10 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1487
1484
|
};
|
|
1488
1485
|
assigner?: string;
|
|
1489
1486
|
}[];
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
templated?: boolean;
|
|
1495
|
-
};
|
|
1496
|
-
upgrade?: {
|
|
1497
|
-
type?: string;
|
|
1498
|
-
href?: string;
|
|
1499
|
-
templated?: boolean;
|
|
1500
|
-
};
|
|
1501
|
-
downgrade?: {
|
|
1502
|
-
type?: string;
|
|
1503
|
-
href?: string;
|
|
1504
|
-
templated?: boolean;
|
|
1505
|
-
};
|
|
1506
|
-
person?: {
|
|
1507
|
-
type?: string;
|
|
1508
|
-
href?: string;
|
|
1509
|
-
templated?: boolean;
|
|
1510
|
-
};
|
|
1511
|
-
networkLink?: {
|
|
1512
|
-
type?: string;
|
|
1513
|
-
href?: string;
|
|
1514
|
-
templated?: boolean;
|
|
1515
|
-
};
|
|
1516
|
-
personMatch?: {
|
|
1517
|
-
type?: string;
|
|
1518
|
-
href?: string;
|
|
1519
|
-
templated?: boolean;
|
|
1520
|
-
};
|
|
1487
|
+
provider?: {
|
|
1488
|
+
type?: string;
|
|
1489
|
+
reference?: string;
|
|
1490
|
+
display?: string;
|
|
1521
1491
|
};
|
|
1522
1492
|
details?: {
|
|
1523
1493
|
identifier?: {
|
|
@@ -1532,21 +1502,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1532
1502
|
assigner?: string;
|
|
1533
1503
|
}[];
|
|
1534
1504
|
name?: {
|
|
1535
|
-
text?: string;
|
|
1536
1505
|
use?: string;
|
|
1537
|
-
|
|
1538
|
-
start?: string;
|
|
1539
|
-
end?: string;
|
|
1540
|
-
};
|
|
1506
|
+
text?: string;
|
|
1541
1507
|
family?: string[];
|
|
1542
1508
|
given?: string[];
|
|
1543
1509
|
prefix?: string;
|
|
1544
1510
|
suffix?: string;
|
|
1511
|
+
period?: {
|
|
1512
|
+
start?: string;
|
|
1513
|
+
end?: string;
|
|
1514
|
+
};
|
|
1545
1515
|
}[];
|
|
1546
1516
|
telecom?: {
|
|
1547
|
-
value?: string;
|
|
1548
|
-
system?: string;
|
|
1549
1517
|
use?: string;
|
|
1518
|
+
system?: string;
|
|
1519
|
+
value?: string;
|
|
1550
1520
|
period?: {
|
|
1551
1521
|
start?: string;
|
|
1552
1522
|
end?: string;
|
|
@@ -1554,90 +1524,90 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1554
1524
|
}[];
|
|
1555
1525
|
gender?: {
|
|
1556
1526
|
code?: string;
|
|
1557
|
-
system?: string;
|
|
1558
1527
|
display?: string;
|
|
1528
|
+
system?: string;
|
|
1559
1529
|
};
|
|
1560
1530
|
birthDate?: string;
|
|
1561
1531
|
address?: {
|
|
1562
1532
|
use?: string;
|
|
1563
|
-
period?: {
|
|
1564
|
-
start?: string;
|
|
1565
|
-
end?: string;
|
|
1566
|
-
};
|
|
1567
1533
|
line?: string[];
|
|
1568
1534
|
city?: string;
|
|
1569
1535
|
state?: string;
|
|
1570
1536
|
zip?: string;
|
|
1571
1537
|
country?: string;
|
|
1572
|
-
}[];
|
|
1573
|
-
picture?: any;
|
|
1574
|
-
};
|
|
1575
|
-
active?: boolean;
|
|
1576
|
-
provider?: {
|
|
1577
|
-
type?: string;
|
|
1578
|
-
display?: string;
|
|
1579
|
-
reference?: string;
|
|
1580
|
-
};
|
|
1581
|
-
facilities?: {
|
|
1582
|
-
name?: string;
|
|
1583
|
-
address?: {
|
|
1584
|
-
use?: string;
|
|
1585
1538
|
period?: {
|
|
1586
1539
|
start?: string;
|
|
1587
1540
|
end?: string;
|
|
1588
1541
|
};
|
|
1589
|
-
|
|
1590
|
-
|
|
1591
|
-
|
|
1592
|
-
|
|
1593
|
-
|
|
1542
|
+
}[];
|
|
1543
|
+
picture?: any;
|
|
1544
|
+
};
|
|
1545
|
+
_links?: {
|
|
1546
|
+
self?: {
|
|
1547
|
+
href?: string;
|
|
1548
|
+
templated?: boolean;
|
|
1549
|
+
type?: string;
|
|
1594
1550
|
};
|
|
1595
|
-
|
|
1596
|
-
}[];
|
|
1597
|
-
}, {
|
|
1598
|
-
identifier?: {
|
|
1599
|
-
system?: string;
|
|
1600
|
-
key?: string;
|
|
1601
|
-
use?: string;
|
|
1602
|
-
label?: string;
|
|
1603
|
-
period?: {
|
|
1604
|
-
start?: string;
|
|
1605
|
-
end?: string;
|
|
1606
|
-
};
|
|
1607
|
-
assigner?: string;
|
|
1608
|
-
}[];
|
|
1609
|
-
_links?: {
|
|
1610
|
-
self?: {
|
|
1611
|
-
type?: string;
|
|
1551
|
+
networkLink?: {
|
|
1612
1552
|
href?: string;
|
|
1613
1553
|
templated?: boolean;
|
|
1614
|
-
};
|
|
1615
|
-
upgrade?: {
|
|
1616
1554
|
type?: string;
|
|
1617
|
-
href?: string;
|
|
1618
|
-
templated?: boolean;
|
|
1619
1555
|
};
|
|
1620
|
-
|
|
1621
|
-
type?: string;
|
|
1556
|
+
person?: {
|
|
1622
1557
|
href?: string;
|
|
1623
1558
|
templated?: boolean;
|
|
1624
|
-
};
|
|
1625
|
-
person?: {
|
|
1626
1559
|
type?: string;
|
|
1560
|
+
};
|
|
1561
|
+
personMatch?: {
|
|
1627
1562
|
href?: string;
|
|
1628
1563
|
templated?: boolean;
|
|
1629
|
-
};
|
|
1630
|
-
networkLink?: {
|
|
1631
1564
|
type?: string;
|
|
1565
|
+
};
|
|
1566
|
+
upgrade?: {
|
|
1632
1567
|
href?: string;
|
|
1633
1568
|
templated?: boolean;
|
|
1634
|
-
};
|
|
1635
|
-
personMatch?: {
|
|
1636
1569
|
type?: string;
|
|
1570
|
+
};
|
|
1571
|
+
downgrade?: {
|
|
1637
1572
|
href?: string;
|
|
1638
1573
|
templated?: boolean;
|
|
1574
|
+
type?: string;
|
|
1639
1575
|
};
|
|
1640
1576
|
};
|
|
1577
|
+
facilities?: {
|
|
1578
|
+
id?: string;
|
|
1579
|
+
name?: string;
|
|
1580
|
+
address?: {
|
|
1581
|
+
use?: string;
|
|
1582
|
+
line?: string[];
|
|
1583
|
+
city?: string;
|
|
1584
|
+
state?: string;
|
|
1585
|
+
zip?: string;
|
|
1586
|
+
country?: string;
|
|
1587
|
+
period?: {
|
|
1588
|
+
start?: string;
|
|
1589
|
+
end?: string;
|
|
1590
|
+
};
|
|
1591
|
+
};
|
|
1592
|
+
}[];
|
|
1593
|
+
}, {
|
|
1594
|
+
active?: boolean;
|
|
1595
|
+
identifier?: {
|
|
1596
|
+
system?: string;
|
|
1597
|
+
key?: string;
|
|
1598
|
+
use?: string;
|
|
1599
|
+
label?: string;
|
|
1600
|
+
period?: {
|
|
1601
|
+
start?: string;
|
|
1602
|
+
end?: string;
|
|
1603
|
+
};
|
|
1604
|
+
assigner?: string;
|
|
1605
|
+
}[];
|
|
1606
|
+
provider?: {
|
|
1607
|
+
type?: string;
|
|
1608
|
+
reference?: string;
|
|
1609
|
+
display?: string;
|
|
1610
|
+
};
|
|
1641
1611
|
details?: {
|
|
1642
1612
|
identifier?: {
|
|
1643
1613
|
system?: string;
|
|
@@ -1651,21 +1621,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1651
1621
|
assigner?: string;
|
|
1652
1622
|
}[];
|
|
1653
1623
|
name?: {
|
|
1654
|
-
text?: string;
|
|
1655
1624
|
use?: string;
|
|
1656
|
-
|
|
1657
|
-
start?: string;
|
|
1658
|
-
end?: string;
|
|
1659
|
-
};
|
|
1625
|
+
text?: string;
|
|
1660
1626
|
family?: string[];
|
|
1661
1627
|
given?: string[];
|
|
1662
1628
|
prefix?: string;
|
|
1663
1629
|
suffix?: string;
|
|
1630
|
+
period?: {
|
|
1631
|
+
start?: string;
|
|
1632
|
+
end?: string;
|
|
1633
|
+
};
|
|
1664
1634
|
}[];
|
|
1665
1635
|
telecom?: {
|
|
1666
|
-
value?: string;
|
|
1667
|
-
system?: string;
|
|
1668
1636
|
use?: string;
|
|
1637
|
+
system?: string;
|
|
1638
|
+
value?: string;
|
|
1669
1639
|
period?: {
|
|
1670
1640
|
start?: string;
|
|
1671
1641
|
end?: string;
|
|
@@ -1673,49 +1643,76 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1673
1643
|
}[];
|
|
1674
1644
|
gender?: {
|
|
1675
1645
|
code?: string;
|
|
1676
|
-
system?: string;
|
|
1677
1646
|
display?: string;
|
|
1647
|
+
system?: string;
|
|
1678
1648
|
};
|
|
1679
1649
|
birthDate?: string;
|
|
1680
1650
|
address?: {
|
|
1681
1651
|
use?: string;
|
|
1682
|
-
period?: {
|
|
1683
|
-
start?: string;
|
|
1684
|
-
end?: string;
|
|
1685
|
-
};
|
|
1686
1652
|
line?: string[];
|
|
1687
1653
|
city?: string;
|
|
1688
1654
|
state?: string;
|
|
1689
1655
|
zip?: string;
|
|
1690
1656
|
country?: string;
|
|
1657
|
+
period?: {
|
|
1658
|
+
start?: string;
|
|
1659
|
+
end?: string;
|
|
1660
|
+
};
|
|
1691
1661
|
}[];
|
|
1692
1662
|
picture?: any;
|
|
1693
1663
|
};
|
|
1694
|
-
|
|
1695
|
-
|
|
1696
|
-
|
|
1697
|
-
|
|
1698
|
-
|
|
1664
|
+
_links?: {
|
|
1665
|
+
self?: {
|
|
1666
|
+
href?: string;
|
|
1667
|
+
templated?: boolean;
|
|
1668
|
+
type?: string;
|
|
1669
|
+
};
|
|
1670
|
+
networkLink?: {
|
|
1671
|
+
href?: string;
|
|
1672
|
+
templated?: boolean;
|
|
1673
|
+
type?: string;
|
|
1674
|
+
};
|
|
1675
|
+
person?: {
|
|
1676
|
+
href?: string;
|
|
1677
|
+
templated?: boolean;
|
|
1678
|
+
type?: string;
|
|
1679
|
+
};
|
|
1680
|
+
personMatch?: {
|
|
1681
|
+
href?: string;
|
|
1682
|
+
templated?: boolean;
|
|
1683
|
+
type?: string;
|
|
1684
|
+
};
|
|
1685
|
+
upgrade?: {
|
|
1686
|
+
href?: string;
|
|
1687
|
+
templated?: boolean;
|
|
1688
|
+
type?: string;
|
|
1689
|
+
};
|
|
1690
|
+
downgrade?: {
|
|
1691
|
+
href?: string;
|
|
1692
|
+
templated?: boolean;
|
|
1693
|
+
type?: string;
|
|
1694
|
+
};
|
|
1699
1695
|
};
|
|
1700
1696
|
facilities?: {
|
|
1697
|
+
id?: string;
|
|
1701
1698
|
name?: string;
|
|
1702
1699
|
address?: {
|
|
1703
1700
|
use?: string;
|
|
1704
|
-
period?: {
|
|
1705
|
-
start?: string;
|
|
1706
|
-
end?: string;
|
|
1707
|
-
};
|
|
1708
1701
|
line?: string[];
|
|
1709
1702
|
city?: string;
|
|
1710
1703
|
state?: string;
|
|
1711
1704
|
zip?: string;
|
|
1712
1705
|
country?: string;
|
|
1706
|
+
period?: {
|
|
1707
|
+
start?: string;
|
|
1708
|
+
end?: string;
|
|
1709
|
+
};
|
|
1713
1710
|
};
|
|
1714
|
-
id?: string;
|
|
1715
1711
|
}[];
|
|
1716
1712
|
}>, "many">;
|
|
1717
1713
|
}, "strip", z.ZodTypeAny, {
|
|
1718
1714
|
patient?: {
|
|
1715
|
+
active?: boolean;
|
|
1719
1716
|
identifier?: {
|
|
1720
1717
|
system?: string;
|
|
1721
1718
|
key?: string;
|
|
@@ -1727,37 +1724,10 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1727
1724
|
};
|
|
1728
1725
|
assigner?: string;
|
|
1729
1726
|
}[];
|
|
1730
|
-
|
|
1731
|
-
|
|
1732
|
-
|
|
1733
|
-
|
|
1734
|
-
templated?: boolean;
|
|
1735
|
-
};
|
|
1736
|
-
upgrade?: {
|
|
1737
|
-
type?: string;
|
|
1738
|
-
href?: string;
|
|
1739
|
-
templated?: boolean;
|
|
1740
|
-
};
|
|
1741
|
-
downgrade?: {
|
|
1742
|
-
type?: string;
|
|
1743
|
-
href?: string;
|
|
1744
|
-
templated?: boolean;
|
|
1745
|
-
};
|
|
1746
|
-
person?: {
|
|
1747
|
-
type?: string;
|
|
1748
|
-
href?: string;
|
|
1749
|
-
templated?: boolean;
|
|
1750
|
-
};
|
|
1751
|
-
networkLink?: {
|
|
1752
|
-
type?: string;
|
|
1753
|
-
href?: string;
|
|
1754
|
-
templated?: boolean;
|
|
1755
|
-
};
|
|
1756
|
-
personMatch?: {
|
|
1757
|
-
type?: string;
|
|
1758
|
-
href?: string;
|
|
1759
|
-
templated?: boolean;
|
|
1760
|
-
};
|
|
1727
|
+
provider?: {
|
|
1728
|
+
type?: string;
|
|
1729
|
+
reference?: string;
|
|
1730
|
+
display?: string;
|
|
1761
1731
|
};
|
|
1762
1732
|
details?: {
|
|
1763
1733
|
identifier?: {
|
|
@@ -1772,21 +1742,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1772
1742
|
assigner?: string;
|
|
1773
1743
|
}[];
|
|
1774
1744
|
name?: {
|
|
1775
|
-
text?: string;
|
|
1776
1745
|
use?: string;
|
|
1777
|
-
|
|
1778
|
-
start?: string;
|
|
1779
|
-
end?: string;
|
|
1780
|
-
};
|
|
1746
|
+
text?: string;
|
|
1781
1747
|
family?: string[];
|
|
1782
1748
|
given?: string[];
|
|
1783
1749
|
prefix?: string;
|
|
1784
1750
|
suffix?: string;
|
|
1751
|
+
period?: {
|
|
1752
|
+
start?: string;
|
|
1753
|
+
end?: string;
|
|
1754
|
+
};
|
|
1785
1755
|
}[];
|
|
1786
1756
|
telecom?: {
|
|
1787
|
-
value?: string;
|
|
1788
|
-
system?: string;
|
|
1789
1757
|
use?: string;
|
|
1758
|
+
system?: string;
|
|
1759
|
+
value?: string;
|
|
1790
1760
|
period?: {
|
|
1791
1761
|
start?: string;
|
|
1792
1762
|
end?: string;
|
|
@@ -1794,49 +1764,76 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1794
1764
|
}[];
|
|
1795
1765
|
gender?: {
|
|
1796
1766
|
code?: string;
|
|
1797
|
-
system?: string;
|
|
1798
1767
|
display?: string;
|
|
1768
|
+
system?: string;
|
|
1799
1769
|
};
|
|
1800
1770
|
birthDate?: string;
|
|
1801
1771
|
address?: {
|
|
1802
1772
|
use?: string;
|
|
1803
|
-
period?: {
|
|
1804
|
-
start?: string;
|
|
1805
|
-
end?: string;
|
|
1806
|
-
};
|
|
1807
1773
|
line?: string[];
|
|
1808
1774
|
city?: string;
|
|
1809
1775
|
state?: string;
|
|
1810
1776
|
zip?: string;
|
|
1811
1777
|
country?: string;
|
|
1778
|
+
period?: {
|
|
1779
|
+
start?: string;
|
|
1780
|
+
end?: string;
|
|
1781
|
+
};
|
|
1812
1782
|
}[];
|
|
1813
1783
|
picture?: any;
|
|
1814
1784
|
};
|
|
1815
|
-
|
|
1816
|
-
|
|
1817
|
-
|
|
1818
|
-
|
|
1819
|
-
|
|
1785
|
+
_links?: {
|
|
1786
|
+
self?: {
|
|
1787
|
+
href?: string;
|
|
1788
|
+
templated?: boolean;
|
|
1789
|
+
type?: string;
|
|
1790
|
+
};
|
|
1791
|
+
networkLink?: {
|
|
1792
|
+
href?: string;
|
|
1793
|
+
templated?: boolean;
|
|
1794
|
+
type?: string;
|
|
1795
|
+
};
|
|
1796
|
+
person?: {
|
|
1797
|
+
href?: string;
|
|
1798
|
+
templated?: boolean;
|
|
1799
|
+
type?: string;
|
|
1800
|
+
};
|
|
1801
|
+
personMatch?: {
|
|
1802
|
+
href?: string;
|
|
1803
|
+
templated?: boolean;
|
|
1804
|
+
type?: string;
|
|
1805
|
+
};
|
|
1806
|
+
upgrade?: {
|
|
1807
|
+
href?: string;
|
|
1808
|
+
templated?: boolean;
|
|
1809
|
+
type?: string;
|
|
1810
|
+
};
|
|
1811
|
+
downgrade?: {
|
|
1812
|
+
href?: string;
|
|
1813
|
+
templated?: boolean;
|
|
1814
|
+
type?: string;
|
|
1815
|
+
};
|
|
1820
1816
|
};
|
|
1821
1817
|
facilities?: {
|
|
1818
|
+
id?: string;
|
|
1822
1819
|
name?: string;
|
|
1823
1820
|
address?: {
|
|
1824
1821
|
use?: string;
|
|
1825
|
-
period?: {
|
|
1826
|
-
start?: string;
|
|
1827
|
-
end?: string;
|
|
1828
|
-
};
|
|
1829
1822
|
line?: string[];
|
|
1830
1823
|
city?: string;
|
|
1831
1824
|
state?: string;
|
|
1832
1825
|
zip?: string;
|
|
1833
1826
|
country?: string;
|
|
1827
|
+
period?: {
|
|
1828
|
+
start?: string;
|
|
1829
|
+
end?: string;
|
|
1830
|
+
};
|
|
1834
1831
|
};
|
|
1835
|
-
id?: string;
|
|
1836
1832
|
}[];
|
|
1837
1833
|
}[];
|
|
1838
1834
|
}, {
|
|
1839
1835
|
patient?: {
|
|
1836
|
+
active?: boolean;
|
|
1840
1837
|
identifier?: {
|
|
1841
1838
|
system?: string;
|
|
1842
1839
|
key?: string;
|
|
@@ -1848,37 +1845,10 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1848
1845
|
};
|
|
1849
1846
|
assigner?: string;
|
|
1850
1847
|
}[];
|
|
1851
|
-
|
|
1852
|
-
|
|
1853
|
-
|
|
1854
|
-
|
|
1855
|
-
templated?: boolean;
|
|
1856
|
-
};
|
|
1857
|
-
upgrade?: {
|
|
1858
|
-
type?: string;
|
|
1859
|
-
href?: string;
|
|
1860
|
-
templated?: boolean;
|
|
1861
|
-
};
|
|
1862
|
-
downgrade?: {
|
|
1863
|
-
type?: string;
|
|
1864
|
-
href?: string;
|
|
1865
|
-
templated?: boolean;
|
|
1866
|
-
};
|
|
1867
|
-
person?: {
|
|
1868
|
-
type?: string;
|
|
1869
|
-
href?: string;
|
|
1870
|
-
templated?: boolean;
|
|
1871
|
-
};
|
|
1872
|
-
networkLink?: {
|
|
1873
|
-
type?: string;
|
|
1874
|
-
href?: string;
|
|
1875
|
-
templated?: boolean;
|
|
1876
|
-
};
|
|
1877
|
-
personMatch?: {
|
|
1878
|
-
type?: string;
|
|
1879
|
-
href?: string;
|
|
1880
|
-
templated?: boolean;
|
|
1881
|
-
};
|
|
1848
|
+
provider?: {
|
|
1849
|
+
type?: string;
|
|
1850
|
+
reference?: string;
|
|
1851
|
+
display?: string;
|
|
1882
1852
|
};
|
|
1883
1853
|
details?: {
|
|
1884
1854
|
identifier?: {
|
|
@@ -1893,21 +1863,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1893
1863
|
assigner?: string;
|
|
1894
1864
|
}[];
|
|
1895
1865
|
name?: {
|
|
1896
|
-
text?: string;
|
|
1897
1866
|
use?: string;
|
|
1898
|
-
|
|
1899
|
-
start?: string;
|
|
1900
|
-
end?: string;
|
|
1901
|
-
};
|
|
1867
|
+
text?: string;
|
|
1902
1868
|
family?: string[];
|
|
1903
1869
|
given?: string[];
|
|
1904
1870
|
prefix?: string;
|
|
1905
1871
|
suffix?: string;
|
|
1872
|
+
period?: {
|
|
1873
|
+
start?: string;
|
|
1874
|
+
end?: string;
|
|
1875
|
+
};
|
|
1906
1876
|
}[];
|
|
1907
1877
|
telecom?: {
|
|
1908
|
-
value?: string;
|
|
1909
|
-
system?: string;
|
|
1910
1878
|
use?: string;
|
|
1879
|
+
system?: string;
|
|
1880
|
+
value?: string;
|
|
1911
1881
|
period?: {
|
|
1912
1882
|
start?: string;
|
|
1913
1883
|
end?: string;
|
|
@@ -1915,45 +1885,71 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1915
1885
|
}[];
|
|
1916
1886
|
gender?: {
|
|
1917
1887
|
code?: string;
|
|
1918
|
-
system?: string;
|
|
1919
1888
|
display?: string;
|
|
1889
|
+
system?: string;
|
|
1920
1890
|
};
|
|
1921
1891
|
birthDate?: string;
|
|
1922
1892
|
address?: {
|
|
1923
1893
|
use?: string;
|
|
1924
|
-
period?: {
|
|
1925
|
-
start?: string;
|
|
1926
|
-
end?: string;
|
|
1927
|
-
};
|
|
1928
1894
|
line?: string[];
|
|
1929
1895
|
city?: string;
|
|
1930
1896
|
state?: string;
|
|
1931
1897
|
zip?: string;
|
|
1932
1898
|
country?: string;
|
|
1899
|
+
period?: {
|
|
1900
|
+
start?: string;
|
|
1901
|
+
end?: string;
|
|
1902
|
+
};
|
|
1933
1903
|
}[];
|
|
1934
1904
|
picture?: any;
|
|
1935
1905
|
};
|
|
1936
|
-
|
|
1937
|
-
|
|
1938
|
-
|
|
1939
|
-
|
|
1940
|
-
|
|
1906
|
+
_links?: {
|
|
1907
|
+
self?: {
|
|
1908
|
+
href?: string;
|
|
1909
|
+
templated?: boolean;
|
|
1910
|
+
type?: string;
|
|
1911
|
+
};
|
|
1912
|
+
networkLink?: {
|
|
1913
|
+
href?: string;
|
|
1914
|
+
templated?: boolean;
|
|
1915
|
+
type?: string;
|
|
1916
|
+
};
|
|
1917
|
+
person?: {
|
|
1918
|
+
href?: string;
|
|
1919
|
+
templated?: boolean;
|
|
1920
|
+
type?: string;
|
|
1921
|
+
};
|
|
1922
|
+
personMatch?: {
|
|
1923
|
+
href?: string;
|
|
1924
|
+
templated?: boolean;
|
|
1925
|
+
type?: string;
|
|
1926
|
+
};
|
|
1927
|
+
upgrade?: {
|
|
1928
|
+
href?: string;
|
|
1929
|
+
templated?: boolean;
|
|
1930
|
+
type?: string;
|
|
1931
|
+
};
|
|
1932
|
+
downgrade?: {
|
|
1933
|
+
href?: string;
|
|
1934
|
+
templated?: boolean;
|
|
1935
|
+
type?: string;
|
|
1936
|
+
};
|
|
1941
1937
|
};
|
|
1942
1938
|
facilities?: {
|
|
1939
|
+
id?: string;
|
|
1943
1940
|
name?: string;
|
|
1944
1941
|
address?: {
|
|
1945
1942
|
use?: string;
|
|
1946
|
-
period?: {
|
|
1947
|
-
start?: string;
|
|
1948
|
-
end?: string;
|
|
1949
|
-
};
|
|
1950
1943
|
line?: string[];
|
|
1951
1944
|
city?: string;
|
|
1952
1945
|
state?: string;
|
|
1953
1946
|
zip?: string;
|
|
1954
1947
|
country?: string;
|
|
1948
|
+
period?: {
|
|
1949
|
+
start?: string;
|
|
1950
|
+
end?: string;
|
|
1951
|
+
};
|
|
1955
1952
|
};
|
|
1956
|
-
id?: string;
|
|
1957
1953
|
}[];
|
|
1958
1954
|
}[];
|
|
1959
1955
|
}>;
|
|
@@ -1963,38 +1959,32 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
1963
1959
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
1964
1960
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
1965
1961
|
}, "strip", z.ZodTypeAny, {
|
|
1966
|
-
type?: string;
|
|
1967
1962
|
href?: string;
|
|
1968
1963
|
templated?: boolean;
|
|
1969
|
-
}, {
|
|
1970
1964
|
type?: string;
|
|
1965
|
+
}, {
|
|
1971
1966
|
href?: string;
|
|
1972
1967
|
templated?: boolean;
|
|
1968
|
+
type?: string;
|
|
1973
1969
|
}>;
|
|
1974
1970
|
}, "strip", z.ZodTypeAny, {
|
|
1975
1971
|
self?: {
|
|
1976
|
-
type?: string;
|
|
1977
1972
|
href?: string;
|
|
1978
1973
|
templated?: boolean;
|
|
1979
|
-
};
|
|
1980
|
-
}, {
|
|
1981
|
-
self?: {
|
|
1982
1974
|
type?: string;
|
|
1983
|
-
href?: string;
|
|
1984
|
-
templated?: boolean;
|
|
1985
1975
|
};
|
|
1986
|
-
}
|
|
1987
|
-
}, "strip", z.ZodTypeAny, {
|
|
1988
|
-
message?: string;
|
|
1989
|
-
_links?: {
|
|
1976
|
+
}, {
|
|
1990
1977
|
self?: {
|
|
1991
|
-
type?: string;
|
|
1992
1978
|
href?: string;
|
|
1993
1979
|
templated?: boolean;
|
|
1980
|
+
type?: string;
|
|
1994
1981
|
};
|
|
1995
|
-
}
|
|
1982
|
+
}>;
|
|
1983
|
+
}, "strip", z.ZodTypeAny, {
|
|
1984
|
+
message?: string;
|
|
1996
1985
|
_embedded?: {
|
|
1997
1986
|
patient?: {
|
|
1987
|
+
active?: boolean;
|
|
1998
1988
|
identifier?: {
|
|
1999
1989
|
system?: string;
|
|
2000
1990
|
key?: string;
|
|
@@ -2006,37 +1996,10 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
2006
1996
|
};
|
|
2007
1997
|
assigner?: string;
|
|
2008
1998
|
}[];
|
|
2009
|
-
|
|
2010
|
-
|
|
2011
|
-
|
|
2012
|
-
|
|
2013
|
-
templated?: boolean;
|
|
2014
|
-
};
|
|
2015
|
-
upgrade?: {
|
|
2016
|
-
type?: string;
|
|
2017
|
-
href?: string;
|
|
2018
|
-
templated?: boolean;
|
|
2019
|
-
};
|
|
2020
|
-
downgrade?: {
|
|
2021
|
-
type?: string;
|
|
2022
|
-
href?: string;
|
|
2023
|
-
templated?: boolean;
|
|
2024
|
-
};
|
|
2025
|
-
person?: {
|
|
2026
|
-
type?: string;
|
|
2027
|
-
href?: string;
|
|
2028
|
-
templated?: boolean;
|
|
2029
|
-
};
|
|
2030
|
-
networkLink?: {
|
|
2031
|
-
type?: string;
|
|
2032
|
-
href?: string;
|
|
2033
|
-
templated?: boolean;
|
|
2034
|
-
};
|
|
2035
|
-
personMatch?: {
|
|
2036
|
-
type?: string;
|
|
2037
|
-
href?: string;
|
|
2038
|
-
templated?: boolean;
|
|
2039
|
-
};
|
|
1999
|
+
provider?: {
|
|
2000
|
+
type?: string;
|
|
2001
|
+
reference?: string;
|
|
2002
|
+
display?: string;
|
|
2040
2003
|
};
|
|
2041
2004
|
details?: {
|
|
2042
2005
|
identifier?: {
|
|
@@ -2051,21 +2014,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
2051
2014
|
assigner?: string;
|
|
2052
2015
|
}[];
|
|
2053
2016
|
name?: {
|
|
2054
|
-
text?: string;
|
|
2055
2017
|
use?: string;
|
|
2056
|
-
|
|
2057
|
-
start?: string;
|
|
2058
|
-
end?: string;
|
|
2059
|
-
};
|
|
2018
|
+
text?: string;
|
|
2060
2019
|
family?: string[];
|
|
2061
2020
|
given?: string[];
|
|
2062
2021
|
prefix?: string;
|
|
2063
2022
|
suffix?: string;
|
|
2023
|
+
period?: {
|
|
2024
|
+
start?: string;
|
|
2025
|
+
end?: string;
|
|
2026
|
+
};
|
|
2064
2027
|
}[];
|
|
2065
2028
|
telecom?: {
|
|
2066
|
-
value?: string;
|
|
2067
|
-
system?: string;
|
|
2068
2029
|
use?: string;
|
|
2030
|
+
system?: string;
|
|
2031
|
+
value?: string;
|
|
2069
2032
|
period?: {
|
|
2070
2033
|
start?: string;
|
|
2071
2034
|
end?: string;
|
|
@@ -2073,59 +2036,86 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
2073
2036
|
}[];
|
|
2074
2037
|
gender?: {
|
|
2075
2038
|
code?: string;
|
|
2076
|
-
system?: string;
|
|
2077
2039
|
display?: string;
|
|
2040
|
+
system?: string;
|
|
2078
2041
|
};
|
|
2079
2042
|
birthDate?: string;
|
|
2080
2043
|
address?: {
|
|
2081
2044
|
use?: string;
|
|
2082
|
-
period?: {
|
|
2083
|
-
start?: string;
|
|
2084
|
-
end?: string;
|
|
2085
|
-
};
|
|
2086
2045
|
line?: string[];
|
|
2087
2046
|
city?: string;
|
|
2088
2047
|
state?: string;
|
|
2089
2048
|
zip?: string;
|
|
2090
2049
|
country?: string;
|
|
2050
|
+
period?: {
|
|
2051
|
+
start?: string;
|
|
2052
|
+
end?: string;
|
|
2053
|
+
};
|
|
2091
2054
|
}[];
|
|
2092
2055
|
picture?: any;
|
|
2093
2056
|
};
|
|
2094
|
-
|
|
2095
|
-
|
|
2096
|
-
|
|
2097
|
-
|
|
2098
|
-
|
|
2057
|
+
_links?: {
|
|
2058
|
+
self?: {
|
|
2059
|
+
href?: string;
|
|
2060
|
+
templated?: boolean;
|
|
2061
|
+
type?: string;
|
|
2062
|
+
};
|
|
2063
|
+
networkLink?: {
|
|
2064
|
+
href?: string;
|
|
2065
|
+
templated?: boolean;
|
|
2066
|
+
type?: string;
|
|
2067
|
+
};
|
|
2068
|
+
person?: {
|
|
2069
|
+
href?: string;
|
|
2070
|
+
templated?: boolean;
|
|
2071
|
+
type?: string;
|
|
2072
|
+
};
|
|
2073
|
+
personMatch?: {
|
|
2074
|
+
href?: string;
|
|
2075
|
+
templated?: boolean;
|
|
2076
|
+
type?: string;
|
|
2077
|
+
};
|
|
2078
|
+
upgrade?: {
|
|
2079
|
+
href?: string;
|
|
2080
|
+
templated?: boolean;
|
|
2081
|
+
type?: string;
|
|
2082
|
+
};
|
|
2083
|
+
downgrade?: {
|
|
2084
|
+
href?: string;
|
|
2085
|
+
templated?: boolean;
|
|
2086
|
+
type?: string;
|
|
2087
|
+
};
|
|
2099
2088
|
};
|
|
2100
2089
|
facilities?: {
|
|
2090
|
+
id?: string;
|
|
2101
2091
|
name?: string;
|
|
2102
2092
|
address?: {
|
|
2103
2093
|
use?: string;
|
|
2104
|
-
period?: {
|
|
2105
|
-
start?: string;
|
|
2106
|
-
end?: string;
|
|
2107
|
-
};
|
|
2108
2094
|
line?: string[];
|
|
2109
2095
|
city?: string;
|
|
2110
2096
|
state?: string;
|
|
2111
2097
|
zip?: string;
|
|
2112
2098
|
country?: string;
|
|
2099
|
+
period?: {
|
|
2100
|
+
start?: string;
|
|
2101
|
+
end?: string;
|
|
2102
|
+
};
|
|
2113
2103
|
};
|
|
2114
|
-
id?: string;
|
|
2115
2104
|
}[];
|
|
2116
2105
|
}[];
|
|
2117
2106
|
};
|
|
2118
|
-
}, {
|
|
2119
|
-
message?: string;
|
|
2120
2107
|
_links?: {
|
|
2121
2108
|
self?: {
|
|
2122
|
-
type?: string;
|
|
2123
2109
|
href?: string;
|
|
2124
2110
|
templated?: boolean;
|
|
2111
|
+
type?: string;
|
|
2125
2112
|
};
|
|
2126
2113
|
};
|
|
2114
|
+
}, {
|
|
2115
|
+
message?: string;
|
|
2127
2116
|
_embedded?: {
|
|
2128
2117
|
patient?: {
|
|
2118
|
+
active?: boolean;
|
|
2129
2119
|
identifier?: {
|
|
2130
2120
|
system?: string;
|
|
2131
2121
|
key?: string;
|
|
@@ -2137,37 +2127,10 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
2137
2127
|
};
|
|
2138
2128
|
assigner?: string;
|
|
2139
2129
|
}[];
|
|
2140
|
-
|
|
2141
|
-
|
|
2142
|
-
|
|
2143
|
-
|
|
2144
|
-
templated?: boolean;
|
|
2145
|
-
};
|
|
2146
|
-
upgrade?: {
|
|
2147
|
-
type?: string;
|
|
2148
|
-
href?: string;
|
|
2149
|
-
templated?: boolean;
|
|
2150
|
-
};
|
|
2151
|
-
downgrade?: {
|
|
2152
|
-
type?: string;
|
|
2153
|
-
href?: string;
|
|
2154
|
-
templated?: boolean;
|
|
2155
|
-
};
|
|
2156
|
-
person?: {
|
|
2157
|
-
type?: string;
|
|
2158
|
-
href?: string;
|
|
2159
|
-
templated?: boolean;
|
|
2160
|
-
};
|
|
2161
|
-
networkLink?: {
|
|
2162
|
-
type?: string;
|
|
2163
|
-
href?: string;
|
|
2164
|
-
templated?: boolean;
|
|
2165
|
-
};
|
|
2166
|
-
personMatch?: {
|
|
2167
|
-
type?: string;
|
|
2168
|
-
href?: string;
|
|
2169
|
-
templated?: boolean;
|
|
2170
|
-
};
|
|
2130
|
+
provider?: {
|
|
2131
|
+
type?: string;
|
|
2132
|
+
reference?: string;
|
|
2133
|
+
display?: string;
|
|
2171
2134
|
};
|
|
2172
2135
|
details?: {
|
|
2173
2136
|
identifier?: {
|
|
@@ -2182,21 +2145,21 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
2182
2145
|
assigner?: string;
|
|
2183
2146
|
}[];
|
|
2184
2147
|
name?: {
|
|
2185
|
-
text?: string;
|
|
2186
2148
|
use?: string;
|
|
2187
|
-
|
|
2188
|
-
start?: string;
|
|
2189
|
-
end?: string;
|
|
2190
|
-
};
|
|
2149
|
+
text?: string;
|
|
2191
2150
|
family?: string[];
|
|
2192
2151
|
given?: string[];
|
|
2193
2152
|
prefix?: string;
|
|
2194
2153
|
suffix?: string;
|
|
2154
|
+
period?: {
|
|
2155
|
+
start?: string;
|
|
2156
|
+
end?: string;
|
|
2157
|
+
};
|
|
2195
2158
|
}[];
|
|
2196
2159
|
telecom?: {
|
|
2197
|
-
value?: string;
|
|
2198
|
-
system?: string;
|
|
2199
2160
|
use?: string;
|
|
2161
|
+
system?: string;
|
|
2162
|
+
value?: string;
|
|
2200
2163
|
period?: {
|
|
2201
2164
|
start?: string;
|
|
2202
2165
|
end?: string;
|
|
@@ -2204,48 +2167,81 @@ export declare const patientSearchRespSchema: z.ZodObject<{
|
|
|
2204
2167
|
}[];
|
|
2205
2168
|
gender?: {
|
|
2206
2169
|
code?: string;
|
|
2207
|
-
system?: string;
|
|
2208
2170
|
display?: string;
|
|
2171
|
+
system?: string;
|
|
2209
2172
|
};
|
|
2210
2173
|
birthDate?: string;
|
|
2211
2174
|
address?: {
|
|
2212
2175
|
use?: string;
|
|
2213
|
-
period?: {
|
|
2214
|
-
start?: string;
|
|
2215
|
-
end?: string;
|
|
2216
|
-
};
|
|
2217
2176
|
line?: string[];
|
|
2218
2177
|
city?: string;
|
|
2219
2178
|
state?: string;
|
|
2220
2179
|
zip?: string;
|
|
2221
2180
|
country?: string;
|
|
2181
|
+
period?: {
|
|
2182
|
+
start?: string;
|
|
2183
|
+
end?: string;
|
|
2184
|
+
};
|
|
2222
2185
|
}[];
|
|
2223
2186
|
picture?: any;
|
|
2224
2187
|
};
|
|
2225
|
-
|
|
2226
|
-
|
|
2227
|
-
|
|
2228
|
-
|
|
2229
|
-
|
|
2188
|
+
_links?: {
|
|
2189
|
+
self?: {
|
|
2190
|
+
href?: string;
|
|
2191
|
+
templated?: boolean;
|
|
2192
|
+
type?: string;
|
|
2193
|
+
};
|
|
2194
|
+
networkLink?: {
|
|
2195
|
+
href?: string;
|
|
2196
|
+
templated?: boolean;
|
|
2197
|
+
type?: string;
|
|
2198
|
+
};
|
|
2199
|
+
person?: {
|
|
2200
|
+
href?: string;
|
|
2201
|
+
templated?: boolean;
|
|
2202
|
+
type?: string;
|
|
2203
|
+
};
|
|
2204
|
+
personMatch?: {
|
|
2205
|
+
href?: string;
|
|
2206
|
+
templated?: boolean;
|
|
2207
|
+
type?: string;
|
|
2208
|
+
};
|
|
2209
|
+
upgrade?: {
|
|
2210
|
+
href?: string;
|
|
2211
|
+
templated?: boolean;
|
|
2212
|
+
type?: string;
|
|
2213
|
+
};
|
|
2214
|
+
downgrade?: {
|
|
2215
|
+
href?: string;
|
|
2216
|
+
templated?: boolean;
|
|
2217
|
+
type?: string;
|
|
2218
|
+
};
|
|
2230
2219
|
};
|
|
2231
2220
|
facilities?: {
|
|
2221
|
+
id?: string;
|
|
2232
2222
|
name?: string;
|
|
2233
2223
|
address?: {
|
|
2234
2224
|
use?: string;
|
|
2235
|
-
period?: {
|
|
2236
|
-
start?: string;
|
|
2237
|
-
end?: string;
|
|
2238
|
-
};
|
|
2239
2225
|
line?: string[];
|
|
2240
2226
|
city?: string;
|
|
2241
2227
|
state?: string;
|
|
2242
2228
|
zip?: string;
|
|
2243
2229
|
country?: string;
|
|
2230
|
+
period?: {
|
|
2231
|
+
start?: string;
|
|
2232
|
+
end?: string;
|
|
2233
|
+
};
|
|
2244
2234
|
};
|
|
2245
|
-
id?: string;
|
|
2246
2235
|
}[];
|
|
2247
2236
|
}[];
|
|
2248
2237
|
};
|
|
2238
|
+
_links?: {
|
|
2239
|
+
self?: {
|
|
2240
|
+
href?: string;
|
|
2241
|
+
templated?: boolean;
|
|
2242
|
+
type?: string;
|
|
2243
|
+
};
|
|
2244
|
+
};
|
|
2249
2245
|
}>;
|
|
2250
2246
|
export type PatientSearchResp = z.infer<typeof patientSearchRespSchema>;
|
|
2251
2247
|
export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
@@ -2257,80 +2253,79 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2257
2253
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
2258
2254
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2259
2255
|
}, "strip", z.ZodTypeAny, {
|
|
2260
|
-
type?: string;
|
|
2261
2256
|
href?: string;
|
|
2262
2257
|
templated?: boolean;
|
|
2263
|
-
}, {
|
|
2264
2258
|
type?: string;
|
|
2259
|
+
}, {
|
|
2265
2260
|
href?: string;
|
|
2266
2261
|
templated?: boolean;
|
|
2262
|
+
type?: string;
|
|
2267
2263
|
}>>>;
|
|
2268
2264
|
upgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
2269
2265
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2270
2266
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
2271
2267
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2272
2268
|
}, "strip", z.ZodTypeAny, {
|
|
2273
|
-
type?: string;
|
|
2274
2269
|
href?: string;
|
|
2275
2270
|
templated?: boolean;
|
|
2276
|
-
}, {
|
|
2277
2271
|
type?: string;
|
|
2272
|
+
}, {
|
|
2278
2273
|
href?: string;
|
|
2279
2274
|
templated?: boolean;
|
|
2275
|
+
type?: string;
|
|
2280
2276
|
}>>>;
|
|
2281
2277
|
downgrade: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
2282
2278
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2283
2279
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
2284
2280
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2285
2281
|
}, "strip", z.ZodTypeAny, {
|
|
2286
|
-
type?: string;
|
|
2287
2282
|
href?: string;
|
|
2288
2283
|
templated?: boolean;
|
|
2289
|
-
}, {
|
|
2290
2284
|
type?: string;
|
|
2285
|
+
}, {
|
|
2291
2286
|
href?: string;
|
|
2292
2287
|
templated?: boolean;
|
|
2288
|
+
type?: string;
|
|
2293
2289
|
}>>>;
|
|
2294
2290
|
}, "strip", z.ZodTypeAny, {
|
|
2295
2291
|
self?: {
|
|
2296
|
-
type?: string;
|
|
2297
2292
|
href?: string;
|
|
2298
2293
|
templated?: boolean;
|
|
2294
|
+
type?: string;
|
|
2299
2295
|
};
|
|
2300
2296
|
upgrade?: {
|
|
2301
|
-
type?: string;
|
|
2302
2297
|
href?: string;
|
|
2303
2298
|
templated?: boolean;
|
|
2299
|
+
type?: string;
|
|
2304
2300
|
};
|
|
2305
2301
|
downgrade?: {
|
|
2306
|
-
type?: string;
|
|
2307
2302
|
href?: string;
|
|
2308
2303
|
templated?: boolean;
|
|
2304
|
+
type?: string;
|
|
2309
2305
|
};
|
|
2310
2306
|
}, {
|
|
2311
2307
|
self?: {
|
|
2312
|
-
type?: string;
|
|
2313
2308
|
href?: string;
|
|
2314
2309
|
templated?: boolean;
|
|
2310
|
+
type?: string;
|
|
2315
2311
|
};
|
|
2316
2312
|
upgrade?: {
|
|
2317
|
-
type?: string;
|
|
2318
2313
|
href?: string;
|
|
2319
2314
|
templated?: boolean;
|
|
2315
|
+
type?: string;
|
|
2320
2316
|
};
|
|
2321
2317
|
downgrade?: {
|
|
2322
|
-
type?: string;
|
|
2323
2318
|
href?: string;
|
|
2324
2319
|
templated?: boolean;
|
|
2320
|
+
type?: string;
|
|
2325
2321
|
};
|
|
2326
2322
|
}>>>;
|
|
2327
2323
|
assuranceLevel: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
2328
2324
|
patient: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
2329
2325
|
details: z.ZodObject<{
|
|
2330
|
-
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<
|
|
2326
|
+
identifier: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2331
2327
|
system: z.ZodString;
|
|
2332
2328
|
key: z.ZodString;
|
|
2333
|
-
}, {
|
|
2334
2329
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
2335
2330
|
label: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2336
2331
|
period: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
@@ -2344,7 +2339,7 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2344
2339
|
end?: string;
|
|
2345
2340
|
}>>>;
|
|
2346
2341
|
assigner: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2347
|
-
}
|
|
2342
|
+
}, "strip", z.ZodTypeAny, {
|
|
2348
2343
|
system?: string;
|
|
2349
2344
|
key?: string;
|
|
2350
2345
|
use?: string;
|
|
@@ -2383,27 +2378,27 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2383
2378
|
end?: string;
|
|
2384
2379
|
}>>>;
|
|
2385
2380
|
}, "strip", z.ZodTypeAny, {
|
|
2386
|
-
text?: string;
|
|
2387
2381
|
use?: string;
|
|
2388
|
-
|
|
2389
|
-
start?: string;
|
|
2390
|
-
end?: string;
|
|
2391
|
-
};
|
|
2382
|
+
text?: string;
|
|
2392
2383
|
family?: string[];
|
|
2393
2384
|
given?: string[];
|
|
2394
2385
|
prefix?: string;
|
|
2395
2386
|
suffix?: string;
|
|
2396
|
-
}, {
|
|
2397
|
-
text?: string;
|
|
2398
|
-
use?: string;
|
|
2399
2387
|
period?: {
|
|
2400
2388
|
start?: string;
|
|
2401
2389
|
end?: string;
|
|
2402
2390
|
};
|
|
2391
|
+
}, {
|
|
2392
|
+
use?: string;
|
|
2393
|
+
text?: string;
|
|
2403
2394
|
family?: string[];
|
|
2404
2395
|
given?: string[];
|
|
2405
2396
|
prefix?: string;
|
|
2406
2397
|
suffix?: string;
|
|
2398
|
+
period?: {
|
|
2399
|
+
start?: string;
|
|
2400
|
+
end?: string;
|
|
2401
|
+
};
|
|
2407
2402
|
}>, "many">;
|
|
2408
2403
|
telecom: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
2409
2404
|
use: z.ZodNullable<z.ZodOptional<z.ZodEnum<[string, ...string[]]>>>;
|
|
@@ -2420,17 +2415,17 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2420
2415
|
end?: string;
|
|
2421
2416
|
}>>>;
|
|
2422
2417
|
}, "strip", z.ZodTypeAny, {
|
|
2423
|
-
value?: string;
|
|
2424
|
-
system?: string;
|
|
2425
2418
|
use?: string;
|
|
2419
|
+
system?: string;
|
|
2420
|
+
value?: string;
|
|
2426
2421
|
period?: {
|
|
2427
2422
|
start?: string;
|
|
2428
2423
|
end?: string;
|
|
2429
2424
|
};
|
|
2430
2425
|
}, {
|
|
2431
|
-
value?: string;
|
|
2432
|
-
system?: string;
|
|
2433
2426
|
use?: string;
|
|
2427
|
+
system?: string;
|
|
2428
|
+
value?: string;
|
|
2434
2429
|
period?: {
|
|
2435
2430
|
start?: string;
|
|
2436
2431
|
end?: string;
|
|
@@ -2442,12 +2437,12 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2442
2437
|
system: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
2443
2438
|
}, "strip", z.ZodTypeAny, {
|
|
2444
2439
|
code?: string;
|
|
2445
|
-
system?: string;
|
|
2446
2440
|
display?: string;
|
|
2441
|
+
system?: string;
|
|
2447
2442
|
}, {
|
|
2448
2443
|
code?: string;
|
|
2449
|
-
system?: string;
|
|
2450
2444
|
display?: string;
|
|
2445
|
+
system?: string;
|
|
2451
2446
|
}>;
|
|
2452
2447
|
birthDate: z.ZodUnion<[z.ZodString, z.ZodString]>;
|
|
2453
2448
|
address: z.ZodArray<z.ZodObject<{
|
|
@@ -2469,26 +2464,26 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2469
2464
|
}>>>;
|
|
2470
2465
|
}, "strip", z.ZodTypeAny, {
|
|
2471
2466
|
use?: string;
|
|
2472
|
-
period?: {
|
|
2473
|
-
start?: string;
|
|
2474
|
-
end?: string;
|
|
2475
|
-
};
|
|
2476
2467
|
line?: string[];
|
|
2477
2468
|
city?: string;
|
|
2478
2469
|
state?: string;
|
|
2479
2470
|
zip?: string;
|
|
2480
2471
|
country?: string;
|
|
2481
|
-
}, {
|
|
2482
|
-
use?: string;
|
|
2483
2472
|
period?: {
|
|
2484
2473
|
start?: string;
|
|
2485
2474
|
end?: string;
|
|
2486
2475
|
};
|
|
2476
|
+
}, {
|
|
2477
|
+
use?: string;
|
|
2487
2478
|
line?: string[];
|
|
2488
2479
|
city?: string;
|
|
2489
2480
|
state?: string;
|
|
2490
2481
|
zip?: string;
|
|
2491
2482
|
country?: string;
|
|
2483
|
+
period?: {
|
|
2484
|
+
start?: string;
|
|
2485
|
+
end?: string;
|
|
2486
|
+
};
|
|
2492
2487
|
}>, "many">;
|
|
2493
2488
|
picture: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
|
|
2494
2489
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -2504,21 +2499,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2504
2499
|
assigner?: string;
|
|
2505
2500
|
}[];
|
|
2506
2501
|
name?: {
|
|
2507
|
-
text?: string;
|
|
2508
2502
|
use?: string;
|
|
2509
|
-
|
|
2510
|
-
start?: string;
|
|
2511
|
-
end?: string;
|
|
2512
|
-
};
|
|
2503
|
+
text?: string;
|
|
2513
2504
|
family?: string[];
|
|
2514
2505
|
given?: string[];
|
|
2515
2506
|
prefix?: string;
|
|
2516
2507
|
suffix?: string;
|
|
2508
|
+
period?: {
|
|
2509
|
+
start?: string;
|
|
2510
|
+
end?: string;
|
|
2511
|
+
};
|
|
2517
2512
|
}[];
|
|
2518
2513
|
telecom?: {
|
|
2519
|
-
value?: string;
|
|
2520
|
-
system?: string;
|
|
2521
2514
|
use?: string;
|
|
2515
|
+
system?: string;
|
|
2516
|
+
value?: string;
|
|
2522
2517
|
period?: {
|
|
2523
2518
|
start?: string;
|
|
2524
2519
|
end?: string;
|
|
@@ -2526,21 +2521,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2526
2521
|
}[];
|
|
2527
2522
|
gender?: {
|
|
2528
2523
|
code?: string;
|
|
2529
|
-
system?: string;
|
|
2530
2524
|
display?: string;
|
|
2525
|
+
system?: string;
|
|
2531
2526
|
};
|
|
2532
2527
|
birthDate?: string;
|
|
2533
2528
|
address?: {
|
|
2534
2529
|
use?: string;
|
|
2535
|
-
period?: {
|
|
2536
|
-
start?: string;
|
|
2537
|
-
end?: string;
|
|
2538
|
-
};
|
|
2539
2530
|
line?: string[];
|
|
2540
2531
|
city?: string;
|
|
2541
2532
|
state?: string;
|
|
2542
2533
|
zip?: string;
|
|
2543
2534
|
country?: string;
|
|
2535
|
+
period?: {
|
|
2536
|
+
start?: string;
|
|
2537
|
+
end?: string;
|
|
2538
|
+
};
|
|
2544
2539
|
}[];
|
|
2545
2540
|
picture?: any;
|
|
2546
2541
|
}, {
|
|
@@ -2556,21 +2551,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2556
2551
|
assigner?: string;
|
|
2557
2552
|
}[];
|
|
2558
2553
|
name?: {
|
|
2559
|
-
text?: string;
|
|
2560
2554
|
use?: string;
|
|
2561
|
-
|
|
2562
|
-
start?: string;
|
|
2563
|
-
end?: string;
|
|
2564
|
-
};
|
|
2555
|
+
text?: string;
|
|
2565
2556
|
family?: string[];
|
|
2566
2557
|
given?: string[];
|
|
2567
2558
|
prefix?: string;
|
|
2568
2559
|
suffix?: string;
|
|
2560
|
+
period?: {
|
|
2561
|
+
start?: string;
|
|
2562
|
+
end?: string;
|
|
2563
|
+
};
|
|
2569
2564
|
}[];
|
|
2570
2565
|
telecom?: {
|
|
2571
|
-
value?: string;
|
|
2572
|
-
system?: string;
|
|
2573
2566
|
use?: string;
|
|
2567
|
+
system?: string;
|
|
2568
|
+
value?: string;
|
|
2574
2569
|
period?: {
|
|
2575
2570
|
start?: string;
|
|
2576
2571
|
end?: string;
|
|
@@ -2578,21 +2573,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2578
2573
|
}[];
|
|
2579
2574
|
gender?: {
|
|
2580
2575
|
code?: string;
|
|
2581
|
-
system?: string;
|
|
2582
2576
|
display?: string;
|
|
2577
|
+
system?: string;
|
|
2583
2578
|
};
|
|
2584
2579
|
birthDate?: string;
|
|
2585
2580
|
address?: {
|
|
2586
2581
|
use?: string;
|
|
2587
|
-
period?: {
|
|
2588
|
-
start?: string;
|
|
2589
|
-
end?: string;
|
|
2590
|
-
};
|
|
2591
2582
|
line?: string[];
|
|
2592
2583
|
city?: string;
|
|
2593
2584
|
state?: string;
|
|
2594
2585
|
zip?: string;
|
|
2595
2586
|
country?: string;
|
|
2587
|
+
period?: {
|
|
2588
|
+
start?: string;
|
|
2589
|
+
end?: string;
|
|
2590
|
+
};
|
|
2596
2591
|
}[];
|
|
2597
2592
|
picture?: any;
|
|
2598
2593
|
}>;
|
|
@@ -2610,21 +2605,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2610
2605
|
assigner?: string;
|
|
2611
2606
|
}[];
|
|
2612
2607
|
name?: {
|
|
2613
|
-
text?: string;
|
|
2614
2608
|
use?: string;
|
|
2615
|
-
|
|
2616
|
-
start?: string;
|
|
2617
|
-
end?: string;
|
|
2618
|
-
};
|
|
2609
|
+
text?: string;
|
|
2619
2610
|
family?: string[];
|
|
2620
2611
|
given?: string[];
|
|
2621
2612
|
prefix?: string;
|
|
2622
2613
|
suffix?: string;
|
|
2614
|
+
period?: {
|
|
2615
|
+
start?: string;
|
|
2616
|
+
end?: string;
|
|
2617
|
+
};
|
|
2623
2618
|
}[];
|
|
2624
2619
|
telecom?: {
|
|
2625
|
-
value?: string;
|
|
2626
|
-
system?: string;
|
|
2627
2620
|
use?: string;
|
|
2621
|
+
system?: string;
|
|
2622
|
+
value?: string;
|
|
2628
2623
|
period?: {
|
|
2629
2624
|
start?: string;
|
|
2630
2625
|
end?: string;
|
|
@@ -2632,21 +2627,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2632
2627
|
}[];
|
|
2633
2628
|
gender?: {
|
|
2634
2629
|
code?: string;
|
|
2635
|
-
system?: string;
|
|
2636
2630
|
display?: string;
|
|
2631
|
+
system?: string;
|
|
2637
2632
|
};
|
|
2638
2633
|
birthDate?: string;
|
|
2639
2634
|
address?: {
|
|
2640
2635
|
use?: string;
|
|
2641
|
-
period?: {
|
|
2642
|
-
start?: string;
|
|
2643
|
-
end?: string;
|
|
2644
|
-
};
|
|
2645
2636
|
line?: string[];
|
|
2646
2637
|
city?: string;
|
|
2647
2638
|
state?: string;
|
|
2648
2639
|
zip?: string;
|
|
2649
2640
|
country?: string;
|
|
2641
|
+
period?: {
|
|
2642
|
+
start?: string;
|
|
2643
|
+
end?: string;
|
|
2644
|
+
};
|
|
2650
2645
|
}[];
|
|
2651
2646
|
picture?: any;
|
|
2652
2647
|
};
|
|
@@ -2664,21 +2659,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2664
2659
|
assigner?: string;
|
|
2665
2660
|
}[];
|
|
2666
2661
|
name?: {
|
|
2667
|
-
text?: string;
|
|
2668
2662
|
use?: string;
|
|
2669
|
-
|
|
2670
|
-
start?: string;
|
|
2671
|
-
end?: string;
|
|
2672
|
-
};
|
|
2663
|
+
text?: string;
|
|
2673
2664
|
family?: string[];
|
|
2674
2665
|
given?: string[];
|
|
2675
2666
|
prefix?: string;
|
|
2676
2667
|
suffix?: string;
|
|
2668
|
+
period?: {
|
|
2669
|
+
start?: string;
|
|
2670
|
+
end?: string;
|
|
2671
|
+
};
|
|
2677
2672
|
}[];
|
|
2678
2673
|
telecom?: {
|
|
2679
|
-
value?: string;
|
|
2680
|
-
system?: string;
|
|
2681
2674
|
use?: string;
|
|
2675
|
+
system?: string;
|
|
2676
|
+
value?: string;
|
|
2682
2677
|
period?: {
|
|
2683
2678
|
start?: string;
|
|
2684
2679
|
end?: string;
|
|
@@ -2686,21 +2681,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2686
2681
|
}[];
|
|
2687
2682
|
gender?: {
|
|
2688
2683
|
code?: string;
|
|
2689
|
-
system?: string;
|
|
2690
2684
|
display?: string;
|
|
2685
|
+
system?: string;
|
|
2691
2686
|
};
|
|
2692
2687
|
birthDate?: string;
|
|
2693
2688
|
address?: {
|
|
2694
2689
|
use?: string;
|
|
2695
|
-
period?: {
|
|
2696
|
-
start?: string;
|
|
2697
|
-
end?: string;
|
|
2698
|
-
};
|
|
2699
2690
|
line?: string[];
|
|
2700
2691
|
city?: string;
|
|
2701
2692
|
state?: string;
|
|
2702
2693
|
zip?: string;
|
|
2703
2694
|
country?: string;
|
|
2695
|
+
period?: {
|
|
2696
|
+
start?: string;
|
|
2697
|
+
end?: string;
|
|
2698
|
+
};
|
|
2704
2699
|
}[];
|
|
2705
2700
|
picture?: any;
|
|
2706
2701
|
};
|
|
@@ -2708,19 +2703,19 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2708
2703
|
}, "strip", z.ZodTypeAny, {
|
|
2709
2704
|
_links?: {
|
|
2710
2705
|
self?: {
|
|
2711
|
-
type?: string;
|
|
2712
2706
|
href?: string;
|
|
2713
2707
|
templated?: boolean;
|
|
2708
|
+
type?: string;
|
|
2714
2709
|
};
|
|
2715
2710
|
upgrade?: {
|
|
2716
|
-
type?: string;
|
|
2717
2711
|
href?: string;
|
|
2718
2712
|
templated?: boolean;
|
|
2713
|
+
type?: string;
|
|
2719
2714
|
};
|
|
2720
2715
|
downgrade?: {
|
|
2721
|
-
type?: string;
|
|
2722
2716
|
href?: string;
|
|
2723
2717
|
templated?: boolean;
|
|
2718
|
+
type?: string;
|
|
2724
2719
|
};
|
|
2725
2720
|
};
|
|
2726
2721
|
assuranceLevel?: string;
|
|
@@ -2738,21 +2733,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2738
2733
|
assigner?: string;
|
|
2739
2734
|
}[];
|
|
2740
2735
|
name?: {
|
|
2741
|
-
text?: string;
|
|
2742
2736
|
use?: string;
|
|
2743
|
-
|
|
2744
|
-
start?: string;
|
|
2745
|
-
end?: string;
|
|
2746
|
-
};
|
|
2737
|
+
text?: string;
|
|
2747
2738
|
family?: string[];
|
|
2748
2739
|
given?: string[];
|
|
2749
2740
|
prefix?: string;
|
|
2750
2741
|
suffix?: string;
|
|
2742
|
+
period?: {
|
|
2743
|
+
start?: string;
|
|
2744
|
+
end?: string;
|
|
2745
|
+
};
|
|
2751
2746
|
}[];
|
|
2752
2747
|
telecom?: {
|
|
2753
|
-
value?: string;
|
|
2754
|
-
system?: string;
|
|
2755
2748
|
use?: string;
|
|
2749
|
+
system?: string;
|
|
2750
|
+
value?: string;
|
|
2756
2751
|
period?: {
|
|
2757
2752
|
start?: string;
|
|
2758
2753
|
end?: string;
|
|
@@ -2760,21 +2755,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2760
2755
|
}[];
|
|
2761
2756
|
gender?: {
|
|
2762
2757
|
code?: string;
|
|
2763
|
-
system?: string;
|
|
2764
2758
|
display?: string;
|
|
2759
|
+
system?: string;
|
|
2765
2760
|
};
|
|
2766
2761
|
birthDate?: string;
|
|
2767
2762
|
address?: {
|
|
2768
2763
|
use?: string;
|
|
2769
|
-
period?: {
|
|
2770
|
-
start?: string;
|
|
2771
|
-
end?: string;
|
|
2772
|
-
};
|
|
2773
2764
|
line?: string[];
|
|
2774
2765
|
city?: string;
|
|
2775
2766
|
state?: string;
|
|
2776
2767
|
zip?: string;
|
|
2777
2768
|
country?: string;
|
|
2769
|
+
period?: {
|
|
2770
|
+
start?: string;
|
|
2771
|
+
end?: string;
|
|
2772
|
+
};
|
|
2778
2773
|
}[];
|
|
2779
2774
|
picture?: any;
|
|
2780
2775
|
};
|
|
@@ -2782,19 +2777,19 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2782
2777
|
}, {
|
|
2783
2778
|
_links?: {
|
|
2784
2779
|
self?: {
|
|
2785
|
-
type?: string;
|
|
2786
2780
|
href?: string;
|
|
2787
2781
|
templated?: boolean;
|
|
2782
|
+
type?: string;
|
|
2788
2783
|
};
|
|
2789
2784
|
upgrade?: {
|
|
2790
|
-
type?: string;
|
|
2791
2785
|
href?: string;
|
|
2792
2786
|
templated?: boolean;
|
|
2787
|
+
type?: string;
|
|
2793
2788
|
};
|
|
2794
2789
|
downgrade?: {
|
|
2795
|
-
type?: string;
|
|
2796
2790
|
href?: string;
|
|
2797
2791
|
templated?: boolean;
|
|
2792
|
+
type?: string;
|
|
2798
2793
|
};
|
|
2799
2794
|
};
|
|
2800
2795
|
assuranceLevel?: string;
|
|
@@ -2812,21 +2807,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2812
2807
|
assigner?: string;
|
|
2813
2808
|
}[];
|
|
2814
2809
|
name?: {
|
|
2815
|
-
text?: string;
|
|
2816
2810
|
use?: string;
|
|
2817
|
-
|
|
2818
|
-
start?: string;
|
|
2819
|
-
end?: string;
|
|
2820
|
-
};
|
|
2811
|
+
text?: string;
|
|
2821
2812
|
family?: string[];
|
|
2822
2813
|
given?: string[];
|
|
2823
2814
|
prefix?: string;
|
|
2824
2815
|
suffix?: string;
|
|
2816
|
+
period?: {
|
|
2817
|
+
start?: string;
|
|
2818
|
+
end?: string;
|
|
2819
|
+
};
|
|
2825
2820
|
}[];
|
|
2826
2821
|
telecom?: {
|
|
2827
|
-
value?: string;
|
|
2828
|
-
system?: string;
|
|
2829
2822
|
use?: string;
|
|
2823
|
+
system?: string;
|
|
2824
|
+
value?: string;
|
|
2830
2825
|
period?: {
|
|
2831
2826
|
start?: string;
|
|
2832
2827
|
end?: string;
|
|
@@ -2834,21 +2829,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2834
2829
|
}[];
|
|
2835
2830
|
gender?: {
|
|
2836
2831
|
code?: string;
|
|
2837
|
-
system?: string;
|
|
2838
2832
|
display?: string;
|
|
2833
|
+
system?: string;
|
|
2839
2834
|
};
|
|
2840
2835
|
birthDate?: string;
|
|
2841
2836
|
address?: {
|
|
2842
2837
|
use?: string;
|
|
2843
|
-
period?: {
|
|
2844
|
-
start?: string;
|
|
2845
|
-
end?: string;
|
|
2846
|
-
};
|
|
2847
2838
|
line?: string[];
|
|
2848
2839
|
city?: string;
|
|
2849
2840
|
state?: string;
|
|
2850
2841
|
zip?: string;
|
|
2851
2842
|
country?: string;
|
|
2843
|
+
period?: {
|
|
2844
|
+
start?: string;
|
|
2845
|
+
end?: string;
|
|
2846
|
+
};
|
|
2852
2847
|
}[];
|
|
2853
2848
|
picture?: any;
|
|
2854
2849
|
};
|
|
@@ -2858,19 +2853,19 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2858
2853
|
networkLink?: {
|
|
2859
2854
|
_links?: {
|
|
2860
2855
|
self?: {
|
|
2861
|
-
type?: string;
|
|
2862
2856
|
href?: string;
|
|
2863
2857
|
templated?: boolean;
|
|
2858
|
+
type?: string;
|
|
2864
2859
|
};
|
|
2865
2860
|
upgrade?: {
|
|
2866
|
-
type?: string;
|
|
2867
2861
|
href?: string;
|
|
2868
2862
|
templated?: boolean;
|
|
2863
|
+
type?: string;
|
|
2869
2864
|
};
|
|
2870
2865
|
downgrade?: {
|
|
2871
|
-
type?: string;
|
|
2872
2866
|
href?: string;
|
|
2873
2867
|
templated?: boolean;
|
|
2868
|
+
type?: string;
|
|
2874
2869
|
};
|
|
2875
2870
|
};
|
|
2876
2871
|
assuranceLevel?: string;
|
|
@@ -2888,21 +2883,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2888
2883
|
assigner?: string;
|
|
2889
2884
|
}[];
|
|
2890
2885
|
name?: {
|
|
2891
|
-
text?: string;
|
|
2892
2886
|
use?: string;
|
|
2893
|
-
|
|
2894
|
-
start?: string;
|
|
2895
|
-
end?: string;
|
|
2896
|
-
};
|
|
2887
|
+
text?: string;
|
|
2897
2888
|
family?: string[];
|
|
2898
2889
|
given?: string[];
|
|
2899
2890
|
prefix?: string;
|
|
2900
2891
|
suffix?: string;
|
|
2892
|
+
period?: {
|
|
2893
|
+
start?: string;
|
|
2894
|
+
end?: string;
|
|
2895
|
+
};
|
|
2901
2896
|
}[];
|
|
2902
2897
|
telecom?: {
|
|
2903
|
-
value?: string;
|
|
2904
|
-
system?: string;
|
|
2905
2898
|
use?: string;
|
|
2899
|
+
system?: string;
|
|
2900
|
+
value?: string;
|
|
2906
2901
|
period?: {
|
|
2907
2902
|
start?: string;
|
|
2908
2903
|
end?: string;
|
|
@@ -2910,21 +2905,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2910
2905
|
}[];
|
|
2911
2906
|
gender?: {
|
|
2912
2907
|
code?: string;
|
|
2913
|
-
system?: string;
|
|
2914
2908
|
display?: string;
|
|
2909
|
+
system?: string;
|
|
2915
2910
|
};
|
|
2916
2911
|
birthDate?: string;
|
|
2917
2912
|
address?: {
|
|
2918
2913
|
use?: string;
|
|
2919
|
-
period?: {
|
|
2920
|
-
start?: string;
|
|
2921
|
-
end?: string;
|
|
2922
|
-
};
|
|
2923
2914
|
line?: string[];
|
|
2924
2915
|
city?: string;
|
|
2925
2916
|
state?: string;
|
|
2926
2917
|
zip?: string;
|
|
2927
2918
|
country?: string;
|
|
2919
|
+
period?: {
|
|
2920
|
+
start?: string;
|
|
2921
|
+
end?: string;
|
|
2922
|
+
};
|
|
2928
2923
|
}[];
|
|
2929
2924
|
picture?: any;
|
|
2930
2925
|
};
|
|
@@ -2934,19 +2929,19 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2934
2929
|
networkLink?: {
|
|
2935
2930
|
_links?: {
|
|
2936
2931
|
self?: {
|
|
2937
|
-
type?: string;
|
|
2938
2932
|
href?: string;
|
|
2939
2933
|
templated?: boolean;
|
|
2934
|
+
type?: string;
|
|
2940
2935
|
};
|
|
2941
2936
|
upgrade?: {
|
|
2942
|
-
type?: string;
|
|
2943
2937
|
href?: string;
|
|
2944
2938
|
templated?: boolean;
|
|
2939
|
+
type?: string;
|
|
2945
2940
|
};
|
|
2946
2941
|
downgrade?: {
|
|
2947
|
-
type?: string;
|
|
2948
2942
|
href?: string;
|
|
2949
2943
|
templated?: boolean;
|
|
2944
|
+
type?: string;
|
|
2950
2945
|
};
|
|
2951
2946
|
};
|
|
2952
2947
|
assuranceLevel?: string;
|
|
@@ -2964,21 +2959,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2964
2959
|
assigner?: string;
|
|
2965
2960
|
}[];
|
|
2966
2961
|
name?: {
|
|
2967
|
-
text?: string;
|
|
2968
2962
|
use?: string;
|
|
2969
|
-
|
|
2970
|
-
start?: string;
|
|
2971
|
-
end?: string;
|
|
2972
|
-
};
|
|
2963
|
+
text?: string;
|
|
2973
2964
|
family?: string[];
|
|
2974
2965
|
given?: string[];
|
|
2975
2966
|
prefix?: string;
|
|
2976
2967
|
suffix?: string;
|
|
2968
|
+
period?: {
|
|
2969
|
+
start?: string;
|
|
2970
|
+
end?: string;
|
|
2971
|
+
};
|
|
2977
2972
|
}[];
|
|
2978
2973
|
telecom?: {
|
|
2979
|
-
value?: string;
|
|
2980
|
-
system?: string;
|
|
2981
2974
|
use?: string;
|
|
2975
|
+
system?: string;
|
|
2976
|
+
value?: string;
|
|
2982
2977
|
period?: {
|
|
2983
2978
|
start?: string;
|
|
2984
2979
|
end?: string;
|
|
@@ -2986,21 +2981,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
2986
2981
|
}[];
|
|
2987
2982
|
gender?: {
|
|
2988
2983
|
code?: string;
|
|
2989
|
-
system?: string;
|
|
2990
2984
|
display?: string;
|
|
2985
|
+
system?: string;
|
|
2991
2986
|
};
|
|
2992
2987
|
birthDate?: string;
|
|
2993
2988
|
address?: {
|
|
2994
2989
|
use?: string;
|
|
2995
|
-
period?: {
|
|
2996
|
-
start?: string;
|
|
2997
|
-
end?: string;
|
|
2998
|
-
};
|
|
2999
2990
|
line?: string[];
|
|
3000
2991
|
city?: string;
|
|
3001
2992
|
state?: string;
|
|
3002
2993
|
zip?: string;
|
|
3003
2994
|
country?: string;
|
|
2995
|
+
period?: {
|
|
2996
|
+
start?: string;
|
|
2997
|
+
end?: string;
|
|
2998
|
+
};
|
|
3004
2999
|
}[];
|
|
3005
3000
|
picture?: any;
|
|
3006
3001
|
};
|
|
@@ -3013,52 +3008,45 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
3013
3008
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3014
3009
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3015
3010
|
}, "strip", z.ZodTypeAny, {
|
|
3016
|
-
type?: string;
|
|
3017
3011
|
href?: string;
|
|
3018
3012
|
templated?: boolean;
|
|
3019
|
-
}, {
|
|
3020
3013
|
type?: string;
|
|
3014
|
+
}, {
|
|
3021
3015
|
href?: string;
|
|
3022
3016
|
templated?: boolean;
|
|
3017
|
+
type?: string;
|
|
3023
3018
|
}>;
|
|
3024
3019
|
}, "strip", z.ZodTypeAny, {
|
|
3025
3020
|
self?: {
|
|
3026
|
-
type?: string;
|
|
3027
3021
|
href?: string;
|
|
3028
3022
|
templated?: boolean;
|
|
3023
|
+
type?: string;
|
|
3029
3024
|
};
|
|
3030
3025
|
}, {
|
|
3031
3026
|
self?: {
|
|
3032
|
-
type?: string;
|
|
3033
3027
|
href?: string;
|
|
3034
3028
|
templated?: boolean;
|
|
3029
|
+
type?: string;
|
|
3035
3030
|
};
|
|
3036
3031
|
}>>;
|
|
3037
3032
|
}, "strip", z.ZodTypeAny, {
|
|
3038
|
-
_links?: {
|
|
3039
|
-
self?: {
|
|
3040
|
-
type?: string;
|
|
3041
|
-
href?: string;
|
|
3042
|
-
templated?: boolean;
|
|
3043
|
-
};
|
|
3044
|
-
};
|
|
3045
3033
|
_embedded?: {
|
|
3046
3034
|
networkLink?: {
|
|
3047
3035
|
_links?: {
|
|
3048
3036
|
self?: {
|
|
3049
|
-
type?: string;
|
|
3050
3037
|
href?: string;
|
|
3051
3038
|
templated?: boolean;
|
|
3039
|
+
type?: string;
|
|
3052
3040
|
};
|
|
3053
3041
|
upgrade?: {
|
|
3054
|
-
type?: string;
|
|
3055
3042
|
href?: string;
|
|
3056
3043
|
templated?: boolean;
|
|
3044
|
+
type?: string;
|
|
3057
3045
|
};
|
|
3058
3046
|
downgrade?: {
|
|
3059
|
-
type?: string;
|
|
3060
3047
|
href?: string;
|
|
3061
3048
|
templated?: boolean;
|
|
3049
|
+
type?: string;
|
|
3062
3050
|
};
|
|
3063
3051
|
};
|
|
3064
3052
|
assuranceLevel?: string;
|
|
@@ -3076,21 +3064,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
3076
3064
|
assigner?: string;
|
|
3077
3065
|
}[];
|
|
3078
3066
|
name?: {
|
|
3079
|
-
text?: string;
|
|
3080
3067
|
use?: string;
|
|
3081
|
-
|
|
3082
|
-
start?: string;
|
|
3083
|
-
end?: string;
|
|
3084
|
-
};
|
|
3068
|
+
text?: string;
|
|
3085
3069
|
family?: string[];
|
|
3086
3070
|
given?: string[];
|
|
3087
3071
|
prefix?: string;
|
|
3088
3072
|
suffix?: string;
|
|
3073
|
+
period?: {
|
|
3074
|
+
start?: string;
|
|
3075
|
+
end?: string;
|
|
3076
|
+
};
|
|
3089
3077
|
}[];
|
|
3090
3078
|
telecom?: {
|
|
3091
|
-
value?: string;
|
|
3092
|
-
system?: string;
|
|
3093
3079
|
use?: string;
|
|
3080
|
+
system?: string;
|
|
3081
|
+
value?: string;
|
|
3094
3082
|
period?: {
|
|
3095
3083
|
start?: string;
|
|
3096
3084
|
end?: string;
|
|
@@ -3098,52 +3086,52 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
3098
3086
|
}[];
|
|
3099
3087
|
gender?: {
|
|
3100
3088
|
code?: string;
|
|
3101
|
-
system?: string;
|
|
3102
3089
|
display?: string;
|
|
3090
|
+
system?: string;
|
|
3103
3091
|
};
|
|
3104
3092
|
birthDate?: string;
|
|
3105
3093
|
address?: {
|
|
3106
3094
|
use?: string;
|
|
3107
|
-
period?: {
|
|
3108
|
-
start?: string;
|
|
3109
|
-
end?: string;
|
|
3110
|
-
};
|
|
3111
3095
|
line?: string[];
|
|
3112
3096
|
city?: string;
|
|
3113
3097
|
state?: string;
|
|
3114
3098
|
zip?: string;
|
|
3115
3099
|
country?: string;
|
|
3100
|
+
period?: {
|
|
3101
|
+
start?: string;
|
|
3102
|
+
end?: string;
|
|
3103
|
+
};
|
|
3116
3104
|
}[];
|
|
3117
3105
|
picture?: any;
|
|
3118
3106
|
};
|
|
3119
3107
|
};
|
|
3120
3108
|
}[];
|
|
3121
3109
|
};
|
|
3122
|
-
}, {
|
|
3123
3110
|
_links?: {
|
|
3124
3111
|
self?: {
|
|
3125
|
-
type?: string;
|
|
3126
3112
|
href?: string;
|
|
3127
3113
|
templated?: boolean;
|
|
3114
|
+
type?: string;
|
|
3128
3115
|
};
|
|
3129
3116
|
};
|
|
3117
|
+
}, {
|
|
3130
3118
|
_embedded?: {
|
|
3131
3119
|
networkLink?: {
|
|
3132
3120
|
_links?: {
|
|
3133
3121
|
self?: {
|
|
3134
|
-
type?: string;
|
|
3135
3122
|
href?: string;
|
|
3136
3123
|
templated?: boolean;
|
|
3124
|
+
type?: string;
|
|
3137
3125
|
};
|
|
3138
3126
|
upgrade?: {
|
|
3139
|
-
type?: string;
|
|
3140
3127
|
href?: string;
|
|
3141
3128
|
templated?: boolean;
|
|
3129
|
+
type?: string;
|
|
3142
3130
|
};
|
|
3143
3131
|
downgrade?: {
|
|
3144
|
-
type?: string;
|
|
3145
3132
|
href?: string;
|
|
3146
3133
|
templated?: boolean;
|
|
3134
|
+
type?: string;
|
|
3147
3135
|
};
|
|
3148
3136
|
};
|
|
3149
3137
|
assuranceLevel?: string;
|
|
@@ -3161,21 +3149,21 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
3161
3149
|
assigner?: string;
|
|
3162
3150
|
}[];
|
|
3163
3151
|
name?: {
|
|
3164
|
-
text?: string;
|
|
3165
3152
|
use?: string;
|
|
3166
|
-
|
|
3167
|
-
start?: string;
|
|
3168
|
-
end?: string;
|
|
3169
|
-
};
|
|
3153
|
+
text?: string;
|
|
3170
3154
|
family?: string[];
|
|
3171
3155
|
given?: string[];
|
|
3172
3156
|
prefix?: string;
|
|
3173
3157
|
suffix?: string;
|
|
3158
|
+
period?: {
|
|
3159
|
+
start?: string;
|
|
3160
|
+
end?: string;
|
|
3161
|
+
};
|
|
3174
3162
|
}[];
|
|
3175
3163
|
telecom?: {
|
|
3176
|
-
value?: string;
|
|
3177
|
-
system?: string;
|
|
3178
3164
|
use?: string;
|
|
3165
|
+
system?: string;
|
|
3166
|
+
value?: string;
|
|
3179
3167
|
period?: {
|
|
3180
3168
|
start?: string;
|
|
3181
3169
|
end?: string;
|
|
@@ -3183,27 +3171,34 @@ export declare const patientNetworkLinkRespSchema: z.ZodObject<{
|
|
|
3183
3171
|
}[];
|
|
3184
3172
|
gender?: {
|
|
3185
3173
|
code?: string;
|
|
3186
|
-
system?: string;
|
|
3187
3174
|
display?: string;
|
|
3175
|
+
system?: string;
|
|
3188
3176
|
};
|
|
3189
3177
|
birthDate?: string;
|
|
3190
3178
|
address?: {
|
|
3191
3179
|
use?: string;
|
|
3192
|
-
period?: {
|
|
3193
|
-
start?: string;
|
|
3194
|
-
end?: string;
|
|
3195
|
-
};
|
|
3196
3180
|
line?: string[];
|
|
3197
3181
|
city?: string;
|
|
3198
3182
|
state?: string;
|
|
3199
3183
|
zip?: string;
|
|
3200
3184
|
country?: string;
|
|
3185
|
+
period?: {
|
|
3186
|
+
start?: string;
|
|
3187
|
+
end?: string;
|
|
3188
|
+
};
|
|
3201
3189
|
}[];
|
|
3202
3190
|
picture?: any;
|
|
3203
3191
|
};
|
|
3204
3192
|
};
|
|
3205
3193
|
}[];
|
|
3206
3194
|
};
|
|
3195
|
+
_links?: {
|
|
3196
|
+
self?: {
|
|
3197
|
+
href?: string;
|
|
3198
|
+
templated?: boolean;
|
|
3199
|
+
type?: string;
|
|
3200
|
+
};
|
|
3201
|
+
};
|
|
3207
3202
|
}>;
|
|
3208
3203
|
export type PatientNetworkLinkResp = z.infer<typeof patientNetworkLinkRespSchema>;
|
|
3209
3204
|
export declare const patientLinkRespSchema: z.ZodObject<{
|
|
@@ -3217,286 +3212,286 @@ export declare const patientLinkRespSchema: z.ZodObject<{
|
|
|
3217
3212
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3218
3213
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3219
3214
|
}, "strip", z.ZodTypeAny, {
|
|
3220
|
-
type?: string;
|
|
3221
3215
|
href?: string;
|
|
3222
3216
|
templated?: boolean;
|
|
3223
|
-
}, {
|
|
3224
3217
|
type?: string;
|
|
3218
|
+
}, {
|
|
3225
3219
|
href?: string;
|
|
3226
3220
|
templated?: boolean;
|
|
3221
|
+
type?: string;
|
|
3227
3222
|
}>;
|
|
3228
3223
|
patientLink: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
3229
3224
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3230
3225
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3231
3226
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3232
3227
|
}, "strip", z.ZodTypeAny, {
|
|
3233
|
-
type?: string;
|
|
3234
3228
|
href?: string;
|
|
3235
3229
|
templated?: boolean;
|
|
3236
|
-
}, {
|
|
3237
3230
|
type?: string;
|
|
3231
|
+
}, {
|
|
3238
3232
|
href?: string;
|
|
3239
3233
|
templated?: boolean;
|
|
3234
|
+
type?: string;
|
|
3240
3235
|
}>>>;
|
|
3241
3236
|
patientMatch: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
3242
3237
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3243
3238
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3244
3239
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3245
3240
|
}, "strip", z.ZodTypeAny, {
|
|
3246
|
-
type?: string;
|
|
3247
3241
|
href?: string;
|
|
3248
3242
|
templated?: boolean;
|
|
3249
|
-
}, {
|
|
3250
3243
|
type?: string;
|
|
3244
|
+
}, {
|
|
3251
3245
|
href?: string;
|
|
3252
3246
|
templated?: boolean;
|
|
3247
|
+
type?: string;
|
|
3253
3248
|
}>>>;
|
|
3254
3249
|
unenroll: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
3255
3250
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3256
3251
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3257
3252
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3258
3253
|
}, "strip", z.ZodTypeAny, {
|
|
3259
|
-
type?: string;
|
|
3260
3254
|
href?: string;
|
|
3261
3255
|
templated?: boolean;
|
|
3262
|
-
}, {
|
|
3263
3256
|
type?: string;
|
|
3257
|
+
}, {
|
|
3264
3258
|
href?: string;
|
|
3265
3259
|
templated?: boolean;
|
|
3260
|
+
type?: string;
|
|
3266
3261
|
}>>>;
|
|
3267
3262
|
enroll: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
3268
3263
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3269
3264
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3270
3265
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3271
3266
|
}, "strip", z.ZodTypeAny, {
|
|
3272
|
-
type?: string;
|
|
3273
3267
|
href?: string;
|
|
3274
3268
|
templated?: boolean;
|
|
3275
|
-
}, {
|
|
3276
3269
|
type?: string;
|
|
3270
|
+
}, {
|
|
3277
3271
|
href?: string;
|
|
3278
3272
|
templated?: boolean;
|
|
3273
|
+
type?: string;
|
|
3279
3274
|
}>>>;
|
|
3280
3275
|
reset: z.ZodNullable<z.ZodOptional<z.ZodObject<{
|
|
3281
3276
|
href: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3282
3277
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3283
3278
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3284
3279
|
}, "strip", z.ZodTypeAny, {
|
|
3285
|
-
type?: string;
|
|
3286
3280
|
href?: string;
|
|
3287
3281
|
templated?: boolean;
|
|
3288
|
-
}, {
|
|
3289
3282
|
type?: string;
|
|
3283
|
+
}, {
|
|
3290
3284
|
href?: string;
|
|
3291
3285
|
templated?: boolean;
|
|
3286
|
+
type?: string;
|
|
3292
3287
|
}>>>;
|
|
3293
3288
|
}, "strip", z.ZodTypeAny, {
|
|
3294
3289
|
self?: {
|
|
3295
|
-
type?: string;
|
|
3296
3290
|
href?: string;
|
|
3297
3291
|
templated?: boolean;
|
|
3292
|
+
type?: string;
|
|
3298
3293
|
};
|
|
3299
3294
|
patientLink?: {
|
|
3300
|
-
type?: string;
|
|
3301
3295
|
href?: string;
|
|
3302
3296
|
templated?: boolean;
|
|
3297
|
+
type?: string;
|
|
3303
3298
|
};
|
|
3304
3299
|
patientMatch?: {
|
|
3305
|
-
type?: string;
|
|
3306
3300
|
href?: string;
|
|
3307
3301
|
templated?: boolean;
|
|
3302
|
+
type?: string;
|
|
3308
3303
|
};
|
|
3309
3304
|
unenroll?: {
|
|
3310
|
-
type?: string;
|
|
3311
3305
|
href?: string;
|
|
3312
3306
|
templated?: boolean;
|
|
3307
|
+
type?: string;
|
|
3313
3308
|
};
|
|
3314
3309
|
enroll?: {
|
|
3315
|
-
type?: string;
|
|
3316
3310
|
href?: string;
|
|
3317
3311
|
templated?: boolean;
|
|
3312
|
+
type?: string;
|
|
3318
3313
|
};
|
|
3319
3314
|
reset?: {
|
|
3320
|
-
type?: string;
|
|
3321
3315
|
href?: string;
|
|
3322
3316
|
templated?: boolean;
|
|
3317
|
+
type?: string;
|
|
3323
3318
|
};
|
|
3324
3319
|
}, {
|
|
3325
3320
|
self?: {
|
|
3326
|
-
type?: string;
|
|
3327
3321
|
href?: string;
|
|
3328
3322
|
templated?: boolean;
|
|
3323
|
+
type?: string;
|
|
3329
3324
|
};
|
|
3330
3325
|
patientLink?: {
|
|
3331
|
-
type?: string;
|
|
3332
3326
|
href?: string;
|
|
3333
3327
|
templated?: boolean;
|
|
3328
|
+
type?: string;
|
|
3334
3329
|
};
|
|
3335
3330
|
patientMatch?: {
|
|
3336
|
-
type?: string;
|
|
3337
3331
|
href?: string;
|
|
3338
3332
|
templated?: boolean;
|
|
3333
|
+
type?: string;
|
|
3339
3334
|
};
|
|
3340
3335
|
unenroll?: {
|
|
3341
|
-
type?: string;
|
|
3342
3336
|
href?: string;
|
|
3343
3337
|
templated?: boolean;
|
|
3338
|
+
type?: string;
|
|
3344
3339
|
};
|
|
3345
3340
|
enroll?: {
|
|
3346
|
-
type?: string;
|
|
3347
3341
|
href?: string;
|
|
3348
3342
|
templated?: boolean;
|
|
3343
|
+
type?: string;
|
|
3349
3344
|
};
|
|
3350
3345
|
reset?: {
|
|
3351
|
-
type?: string;
|
|
3352
3346
|
href?: string;
|
|
3353
3347
|
templated?: boolean;
|
|
3348
|
+
type?: string;
|
|
3354
3349
|
};
|
|
3355
3350
|
}>>>;
|
|
3356
3351
|
}, "strip", z.ZodTypeAny, {
|
|
3352
|
+
patient?: string;
|
|
3353
|
+
assuranceLevel?: string;
|
|
3357
3354
|
_links?: {
|
|
3358
3355
|
self?: {
|
|
3359
|
-
type?: string;
|
|
3360
3356
|
href?: string;
|
|
3361
3357
|
templated?: boolean;
|
|
3358
|
+
type?: string;
|
|
3362
3359
|
};
|
|
3363
3360
|
patientLink?: {
|
|
3364
|
-
type?: string;
|
|
3365
3361
|
href?: string;
|
|
3366
3362
|
templated?: boolean;
|
|
3363
|
+
type?: string;
|
|
3367
3364
|
};
|
|
3368
3365
|
patientMatch?: {
|
|
3369
|
-
type?: string;
|
|
3370
3366
|
href?: string;
|
|
3371
3367
|
templated?: boolean;
|
|
3368
|
+
type?: string;
|
|
3372
3369
|
};
|
|
3373
3370
|
unenroll?: {
|
|
3374
|
-
type?: string;
|
|
3375
3371
|
href?: string;
|
|
3376
3372
|
templated?: boolean;
|
|
3373
|
+
type?: string;
|
|
3377
3374
|
};
|
|
3378
3375
|
enroll?: {
|
|
3379
|
-
type?: string;
|
|
3380
3376
|
href?: string;
|
|
3381
3377
|
templated?: boolean;
|
|
3378
|
+
type?: string;
|
|
3382
3379
|
};
|
|
3383
3380
|
reset?: {
|
|
3384
|
-
type?: string;
|
|
3385
3381
|
href?: string;
|
|
3386
3382
|
templated?: boolean;
|
|
3383
|
+
type?: string;
|
|
3387
3384
|
};
|
|
3388
3385
|
};
|
|
3389
|
-
assuranceLevel?: string;
|
|
3390
|
-
patient?: string;
|
|
3391
3386
|
}, {
|
|
3387
|
+
patient?: string;
|
|
3388
|
+
assuranceLevel?: string;
|
|
3392
3389
|
_links?: {
|
|
3393
3390
|
self?: {
|
|
3394
|
-
type?: string;
|
|
3395
3391
|
href?: string;
|
|
3396
3392
|
templated?: boolean;
|
|
3393
|
+
type?: string;
|
|
3397
3394
|
};
|
|
3398
3395
|
patientLink?: {
|
|
3399
|
-
type?: string;
|
|
3400
3396
|
href?: string;
|
|
3401
3397
|
templated?: boolean;
|
|
3398
|
+
type?: string;
|
|
3402
3399
|
};
|
|
3403
3400
|
patientMatch?: {
|
|
3404
|
-
type?: string;
|
|
3405
3401
|
href?: string;
|
|
3406
3402
|
templated?: boolean;
|
|
3403
|
+
type?: string;
|
|
3407
3404
|
};
|
|
3408
3405
|
unenroll?: {
|
|
3409
|
-
type?: string;
|
|
3410
3406
|
href?: string;
|
|
3411
3407
|
templated?: boolean;
|
|
3408
|
+
type?: string;
|
|
3412
3409
|
};
|
|
3413
3410
|
enroll?: {
|
|
3414
|
-
type?: string;
|
|
3415
3411
|
href?: string;
|
|
3416
3412
|
templated?: boolean;
|
|
3413
|
+
type?: string;
|
|
3417
3414
|
};
|
|
3418
3415
|
reset?: {
|
|
3419
|
-
type?: string;
|
|
3420
3416
|
href?: string;
|
|
3421
3417
|
templated?: boolean;
|
|
3418
|
+
type?: string;
|
|
3422
3419
|
};
|
|
3423
3420
|
};
|
|
3424
|
-
assuranceLevel?: string;
|
|
3425
|
-
patient?: string;
|
|
3426
3421
|
}>, "many">>>;
|
|
3427
3422
|
}, "strip", z.ZodTypeAny, {
|
|
3428
3423
|
patientLink?: {
|
|
3424
|
+
patient?: string;
|
|
3425
|
+
assuranceLevel?: string;
|
|
3429
3426
|
_links?: {
|
|
3430
3427
|
self?: {
|
|
3431
|
-
type?: string;
|
|
3432
3428
|
href?: string;
|
|
3433
3429
|
templated?: boolean;
|
|
3430
|
+
type?: string;
|
|
3434
3431
|
};
|
|
3435
3432
|
patientLink?: {
|
|
3436
|
-
type?: string;
|
|
3437
3433
|
href?: string;
|
|
3438
3434
|
templated?: boolean;
|
|
3435
|
+
type?: string;
|
|
3439
3436
|
};
|
|
3440
3437
|
patientMatch?: {
|
|
3441
|
-
type?: string;
|
|
3442
3438
|
href?: string;
|
|
3443
3439
|
templated?: boolean;
|
|
3440
|
+
type?: string;
|
|
3444
3441
|
};
|
|
3445
3442
|
unenroll?: {
|
|
3446
|
-
type?: string;
|
|
3447
3443
|
href?: string;
|
|
3448
3444
|
templated?: boolean;
|
|
3445
|
+
type?: string;
|
|
3449
3446
|
};
|
|
3450
3447
|
enroll?: {
|
|
3451
|
-
type?: string;
|
|
3452
3448
|
href?: string;
|
|
3453
3449
|
templated?: boolean;
|
|
3450
|
+
type?: string;
|
|
3454
3451
|
};
|
|
3455
3452
|
reset?: {
|
|
3456
|
-
type?: string;
|
|
3457
3453
|
href?: string;
|
|
3458
3454
|
templated?: boolean;
|
|
3455
|
+
type?: string;
|
|
3459
3456
|
};
|
|
3460
3457
|
};
|
|
3461
|
-
assuranceLevel?: string;
|
|
3462
|
-
patient?: string;
|
|
3463
3458
|
}[];
|
|
3464
3459
|
}, {
|
|
3465
3460
|
patientLink?: {
|
|
3461
|
+
patient?: string;
|
|
3462
|
+
assuranceLevel?: string;
|
|
3466
3463
|
_links?: {
|
|
3467
3464
|
self?: {
|
|
3468
|
-
type?: string;
|
|
3469
3465
|
href?: string;
|
|
3470
3466
|
templated?: boolean;
|
|
3467
|
+
type?: string;
|
|
3471
3468
|
};
|
|
3472
3469
|
patientLink?: {
|
|
3473
|
-
type?: string;
|
|
3474
3470
|
href?: string;
|
|
3475
3471
|
templated?: boolean;
|
|
3472
|
+
type?: string;
|
|
3476
3473
|
};
|
|
3477
3474
|
patientMatch?: {
|
|
3478
|
-
type?: string;
|
|
3479
3475
|
href?: string;
|
|
3480
3476
|
templated?: boolean;
|
|
3477
|
+
type?: string;
|
|
3481
3478
|
};
|
|
3482
3479
|
unenroll?: {
|
|
3483
|
-
type?: string;
|
|
3484
3480
|
href?: string;
|
|
3485
3481
|
templated?: boolean;
|
|
3482
|
+
type?: string;
|
|
3486
3483
|
};
|
|
3487
3484
|
enroll?: {
|
|
3488
|
-
type?: string;
|
|
3489
3485
|
href?: string;
|
|
3490
3486
|
templated?: boolean;
|
|
3487
|
+
type?: string;
|
|
3491
3488
|
};
|
|
3492
3489
|
reset?: {
|
|
3493
|
-
type?: string;
|
|
3494
3490
|
href?: string;
|
|
3495
3491
|
templated?: boolean;
|
|
3492
|
+
type?: string;
|
|
3496
3493
|
};
|
|
3497
3494
|
};
|
|
3498
|
-
assuranceLevel?: string;
|
|
3499
|
-
patient?: string;
|
|
3500
3495
|
}[];
|
|
3501
3496
|
}>;
|
|
3502
3497
|
_links: z.ZodOptional<z.ZodObject<{
|
|
@@ -3505,118 +3500,118 @@ export declare const patientLinkRespSchema: z.ZodObject<{
|
|
|
3505
3500
|
templated: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
|
|
3506
3501
|
type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
|
|
3507
3502
|
}, "strip", z.ZodTypeAny, {
|
|
3508
|
-
type?: string;
|
|
3509
3503
|
href?: string;
|
|
3510
3504
|
templated?: boolean;
|
|
3511
|
-
}, {
|
|
3512
3505
|
type?: string;
|
|
3506
|
+
}, {
|
|
3513
3507
|
href?: string;
|
|
3514
3508
|
templated?: boolean;
|
|
3509
|
+
type?: string;
|
|
3515
3510
|
}>;
|
|
3516
3511
|
}, "strip", z.ZodTypeAny, {
|
|
3517
3512
|
self?: {
|
|
3518
|
-
type?: string;
|
|
3519
3513
|
href?: string;
|
|
3520
3514
|
templated?: boolean;
|
|
3515
|
+
type?: string;
|
|
3521
3516
|
};
|
|
3522
3517
|
}, {
|
|
3523
3518
|
self?: {
|
|
3524
|
-
type?: string;
|
|
3525
3519
|
href?: string;
|
|
3526
3520
|
templated?: boolean;
|
|
3521
|
+
type?: string;
|
|
3527
3522
|
};
|
|
3528
3523
|
}>>;
|
|
3529
3524
|
}, "strip", z.ZodTypeAny, {
|
|
3530
|
-
_links?: {
|
|
3531
|
-
self?: {
|
|
3532
|
-
type?: string;
|
|
3533
|
-
href?: string;
|
|
3534
|
-
templated?: boolean;
|
|
3535
|
-
};
|
|
3536
|
-
};
|
|
3537
3525
|
_embedded?: {
|
|
3538
3526
|
patientLink?: {
|
|
3527
|
+
patient?: string;
|
|
3528
|
+
assuranceLevel?: string;
|
|
3539
3529
|
_links?: {
|
|
3540
3530
|
self?: {
|
|
3541
|
-
type?: string;
|
|
3542
3531
|
href?: string;
|
|
3543
3532
|
templated?: boolean;
|
|
3533
|
+
type?: string;
|
|
3544
3534
|
};
|
|
3545
3535
|
patientLink?: {
|
|
3546
|
-
type?: string;
|
|
3547
3536
|
href?: string;
|
|
3548
3537
|
templated?: boolean;
|
|
3538
|
+
type?: string;
|
|
3549
3539
|
};
|
|
3550
3540
|
patientMatch?: {
|
|
3551
|
-
type?: string;
|
|
3552
3541
|
href?: string;
|
|
3553
3542
|
templated?: boolean;
|
|
3543
|
+
type?: string;
|
|
3554
3544
|
};
|
|
3555
3545
|
unenroll?: {
|
|
3556
|
-
type?: string;
|
|
3557
3546
|
href?: string;
|
|
3558
3547
|
templated?: boolean;
|
|
3548
|
+
type?: string;
|
|
3559
3549
|
};
|
|
3560
3550
|
enroll?: {
|
|
3561
|
-
type?: string;
|
|
3562
3551
|
href?: string;
|
|
3563
3552
|
templated?: boolean;
|
|
3553
|
+
type?: string;
|
|
3564
3554
|
};
|
|
3565
3555
|
reset?: {
|
|
3566
|
-
type?: string;
|
|
3567
3556
|
href?: string;
|
|
3568
3557
|
templated?: boolean;
|
|
3558
|
+
type?: string;
|
|
3569
3559
|
};
|
|
3570
3560
|
};
|
|
3571
|
-
assuranceLevel?: string;
|
|
3572
|
-
patient?: string;
|
|
3573
3561
|
}[];
|
|
3574
3562
|
};
|
|
3575
|
-
}, {
|
|
3576
3563
|
_links?: {
|
|
3577
3564
|
self?: {
|
|
3578
|
-
type?: string;
|
|
3579
3565
|
href?: string;
|
|
3580
3566
|
templated?: boolean;
|
|
3567
|
+
type?: string;
|
|
3581
3568
|
};
|
|
3582
3569
|
};
|
|
3570
|
+
}, {
|
|
3583
3571
|
_embedded?: {
|
|
3584
3572
|
patientLink?: {
|
|
3573
|
+
patient?: string;
|
|
3574
|
+
assuranceLevel?: string;
|
|
3585
3575
|
_links?: {
|
|
3586
3576
|
self?: {
|
|
3587
|
-
type?: string;
|
|
3588
3577
|
href?: string;
|
|
3589
3578
|
templated?: boolean;
|
|
3579
|
+
type?: string;
|
|
3590
3580
|
};
|
|
3591
3581
|
patientLink?: {
|
|
3592
|
-
type?: string;
|
|
3593
3582
|
href?: string;
|
|
3594
3583
|
templated?: boolean;
|
|
3584
|
+
type?: string;
|
|
3595
3585
|
};
|
|
3596
3586
|
patientMatch?: {
|
|
3597
|
-
type?: string;
|
|
3598
3587
|
href?: string;
|
|
3599
3588
|
templated?: boolean;
|
|
3589
|
+
type?: string;
|
|
3600
3590
|
};
|
|
3601
3591
|
unenroll?: {
|
|
3602
|
-
type?: string;
|
|
3603
3592
|
href?: string;
|
|
3604
3593
|
templated?: boolean;
|
|
3594
|
+
type?: string;
|
|
3605
3595
|
};
|
|
3606
3596
|
enroll?: {
|
|
3607
|
-
type?: string;
|
|
3608
3597
|
href?: string;
|
|
3609
3598
|
templated?: boolean;
|
|
3599
|
+
type?: string;
|
|
3610
3600
|
};
|
|
3611
3601
|
reset?: {
|
|
3612
|
-
type?: string;
|
|
3613
3602
|
href?: string;
|
|
3614
3603
|
templated?: boolean;
|
|
3604
|
+
type?: string;
|
|
3615
3605
|
};
|
|
3616
3606
|
};
|
|
3617
|
-
assuranceLevel?: string;
|
|
3618
|
-
patient?: string;
|
|
3619
3607
|
}[];
|
|
3620
3608
|
};
|
|
3609
|
+
_links?: {
|
|
3610
|
+
self?: {
|
|
3611
|
+
href?: string;
|
|
3612
|
+
templated?: boolean;
|
|
3613
|
+
type?: string;
|
|
3614
|
+
};
|
|
3615
|
+
};
|
|
3621
3616
|
}>;
|
|
3622
3617
|
export type PatientLinkResp = z.infer<typeof patientLinkRespSchema>;
|