evo360-types 1.3.538 → 1.3.540
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.
|
@@ -122,6 +122,8 @@ export declare const zAutomationDateWindowSchema: z.ZodObject<{
|
|
|
122
122
|
offset_days: number;
|
|
123
123
|
offset_mode: "calendar" | "business";
|
|
124
124
|
}>;
|
|
125
|
+
export declare const zAutomationTimeOfDaySchema: z.ZodString;
|
|
126
|
+
export declare const zAutomationAppointmentModeSchema: z.ZodEnum<["telemedicine", "in_person"]>;
|
|
125
127
|
export declare const zAutomationAppointmentSelectionSchema: z.ZodObject<{
|
|
126
128
|
target: z.ZodLiteral<"appointment">;
|
|
127
129
|
appointment: z.ZodObject<{
|
|
@@ -144,6 +146,32 @@ export declare const zAutomationAppointmentSelectionSchema: z.ZodObject<{
|
|
|
144
146
|
insurance_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
145
147
|
address_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
146
148
|
payment_status_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
149
|
+
status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
150
|
+
status_base_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
151
|
+
appointment_type_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
152
|
+
professional_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
153
|
+
procedure_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
154
|
+
insurance_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
155
|
+
address_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
156
|
+
payment_status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
157
|
+
appointment_mode_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
158
|
+
appointment_mode_not_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
159
|
+
time_range: z.ZodOptional<z.ZodEffects<z.ZodObject<{
|
|
160
|
+
start: z.ZodString;
|
|
161
|
+
end: z.ZodString;
|
|
162
|
+
}, "strip", z.ZodTypeAny, {
|
|
163
|
+
start: string;
|
|
164
|
+
end: string;
|
|
165
|
+
}, {
|
|
166
|
+
start: string;
|
|
167
|
+
end: string;
|
|
168
|
+
}>, {
|
|
169
|
+
start: string;
|
|
170
|
+
end: string;
|
|
171
|
+
}, {
|
|
172
|
+
start: string;
|
|
173
|
+
end: string;
|
|
174
|
+
}>>;
|
|
147
175
|
}, "strip", z.ZodTypeAny, {
|
|
148
176
|
date_window: {
|
|
149
177
|
offset_days: number;
|
|
@@ -158,6 +186,20 @@ export declare const zAutomationAppointmentSelectionSchema: z.ZodObject<{
|
|
|
158
186
|
insurance_names?: string[] | undefined;
|
|
159
187
|
address_names?: string[] | undefined;
|
|
160
188
|
payment_status_in?: string[] | undefined;
|
|
189
|
+
status_not_in?: string[] | undefined;
|
|
190
|
+
status_base_not_in?: string[] | undefined;
|
|
191
|
+
appointment_type_in?: string[] | undefined;
|
|
192
|
+
professional_names_not_in?: string[] | undefined;
|
|
193
|
+
procedure_names_not_in?: string[] | undefined;
|
|
194
|
+
insurance_names_not_in?: string[] | undefined;
|
|
195
|
+
address_names_not_in?: string[] | undefined;
|
|
196
|
+
payment_status_not_in?: string[] | undefined;
|
|
197
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
198
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
199
|
+
time_range?: {
|
|
200
|
+
start: string;
|
|
201
|
+
end: string;
|
|
202
|
+
} | undefined;
|
|
161
203
|
}, {
|
|
162
204
|
date_window: {
|
|
163
205
|
offset_days: number;
|
|
@@ -172,6 +214,20 @@ export declare const zAutomationAppointmentSelectionSchema: z.ZodObject<{
|
|
|
172
214
|
insurance_names?: string[] | undefined;
|
|
173
215
|
address_names?: string[] | undefined;
|
|
174
216
|
payment_status_in?: string[] | undefined;
|
|
217
|
+
status_not_in?: string[] | undefined;
|
|
218
|
+
status_base_not_in?: string[] | undefined;
|
|
219
|
+
appointment_type_in?: string[] | undefined;
|
|
220
|
+
professional_names_not_in?: string[] | undefined;
|
|
221
|
+
procedure_names_not_in?: string[] | undefined;
|
|
222
|
+
insurance_names_not_in?: string[] | undefined;
|
|
223
|
+
address_names_not_in?: string[] | undefined;
|
|
224
|
+
payment_status_not_in?: string[] | undefined;
|
|
225
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
226
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
227
|
+
time_range?: {
|
|
228
|
+
start: string;
|
|
229
|
+
end: string;
|
|
230
|
+
} | undefined;
|
|
175
231
|
}>;
|
|
176
232
|
}, "strip", z.ZodTypeAny, {
|
|
177
233
|
appointment: {
|
|
@@ -188,6 +244,20 @@ export declare const zAutomationAppointmentSelectionSchema: z.ZodObject<{
|
|
|
188
244
|
insurance_names?: string[] | undefined;
|
|
189
245
|
address_names?: string[] | undefined;
|
|
190
246
|
payment_status_in?: string[] | undefined;
|
|
247
|
+
status_not_in?: string[] | undefined;
|
|
248
|
+
status_base_not_in?: string[] | undefined;
|
|
249
|
+
appointment_type_in?: string[] | undefined;
|
|
250
|
+
professional_names_not_in?: string[] | undefined;
|
|
251
|
+
procedure_names_not_in?: string[] | undefined;
|
|
252
|
+
insurance_names_not_in?: string[] | undefined;
|
|
253
|
+
address_names_not_in?: string[] | undefined;
|
|
254
|
+
payment_status_not_in?: string[] | undefined;
|
|
255
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
256
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
257
|
+
time_range?: {
|
|
258
|
+
start: string;
|
|
259
|
+
end: string;
|
|
260
|
+
} | undefined;
|
|
191
261
|
};
|
|
192
262
|
target: "appointment";
|
|
193
263
|
}, {
|
|
@@ -205,6 +275,20 @@ export declare const zAutomationAppointmentSelectionSchema: z.ZodObject<{
|
|
|
205
275
|
insurance_names?: string[] | undefined;
|
|
206
276
|
address_names?: string[] | undefined;
|
|
207
277
|
payment_status_in?: string[] | undefined;
|
|
278
|
+
status_not_in?: string[] | undefined;
|
|
279
|
+
status_base_not_in?: string[] | undefined;
|
|
280
|
+
appointment_type_in?: string[] | undefined;
|
|
281
|
+
professional_names_not_in?: string[] | undefined;
|
|
282
|
+
procedure_names_not_in?: string[] | undefined;
|
|
283
|
+
insurance_names_not_in?: string[] | undefined;
|
|
284
|
+
address_names_not_in?: string[] | undefined;
|
|
285
|
+
payment_status_not_in?: string[] | undefined;
|
|
286
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
287
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
288
|
+
time_range?: {
|
|
289
|
+
start: string;
|
|
290
|
+
end: string;
|
|
291
|
+
} | undefined;
|
|
208
292
|
};
|
|
209
293
|
target: "appointment";
|
|
210
294
|
}>;
|
|
@@ -295,6 +379,32 @@ export declare const zAutomationSelectionSchema: z.ZodDiscriminatedUnion<"target
|
|
|
295
379
|
insurance_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
296
380
|
address_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
297
381
|
payment_status_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
382
|
+
status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
383
|
+
status_base_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
384
|
+
appointment_type_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
385
|
+
professional_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
386
|
+
procedure_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
387
|
+
insurance_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
388
|
+
address_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
389
|
+
payment_status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
390
|
+
appointment_mode_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
391
|
+
appointment_mode_not_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
392
|
+
time_range: z.ZodOptional<z.ZodEffects<z.ZodObject<{
|
|
393
|
+
start: z.ZodString;
|
|
394
|
+
end: z.ZodString;
|
|
395
|
+
}, "strip", z.ZodTypeAny, {
|
|
396
|
+
start: string;
|
|
397
|
+
end: string;
|
|
398
|
+
}, {
|
|
399
|
+
start: string;
|
|
400
|
+
end: string;
|
|
401
|
+
}>, {
|
|
402
|
+
start: string;
|
|
403
|
+
end: string;
|
|
404
|
+
}, {
|
|
405
|
+
start: string;
|
|
406
|
+
end: string;
|
|
407
|
+
}>>;
|
|
298
408
|
}, "strip", z.ZodTypeAny, {
|
|
299
409
|
date_window: {
|
|
300
410
|
offset_days: number;
|
|
@@ -309,6 +419,20 @@ export declare const zAutomationSelectionSchema: z.ZodDiscriminatedUnion<"target
|
|
|
309
419
|
insurance_names?: string[] | undefined;
|
|
310
420
|
address_names?: string[] | undefined;
|
|
311
421
|
payment_status_in?: string[] | undefined;
|
|
422
|
+
status_not_in?: string[] | undefined;
|
|
423
|
+
status_base_not_in?: string[] | undefined;
|
|
424
|
+
appointment_type_in?: string[] | undefined;
|
|
425
|
+
professional_names_not_in?: string[] | undefined;
|
|
426
|
+
procedure_names_not_in?: string[] | undefined;
|
|
427
|
+
insurance_names_not_in?: string[] | undefined;
|
|
428
|
+
address_names_not_in?: string[] | undefined;
|
|
429
|
+
payment_status_not_in?: string[] | undefined;
|
|
430
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
431
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
432
|
+
time_range?: {
|
|
433
|
+
start: string;
|
|
434
|
+
end: string;
|
|
435
|
+
} | undefined;
|
|
312
436
|
}, {
|
|
313
437
|
date_window: {
|
|
314
438
|
offset_days: number;
|
|
@@ -323,6 +447,20 @@ export declare const zAutomationSelectionSchema: z.ZodDiscriminatedUnion<"target
|
|
|
323
447
|
insurance_names?: string[] | undefined;
|
|
324
448
|
address_names?: string[] | undefined;
|
|
325
449
|
payment_status_in?: string[] | undefined;
|
|
450
|
+
status_not_in?: string[] | undefined;
|
|
451
|
+
status_base_not_in?: string[] | undefined;
|
|
452
|
+
appointment_type_in?: string[] | undefined;
|
|
453
|
+
professional_names_not_in?: string[] | undefined;
|
|
454
|
+
procedure_names_not_in?: string[] | undefined;
|
|
455
|
+
insurance_names_not_in?: string[] | undefined;
|
|
456
|
+
address_names_not_in?: string[] | undefined;
|
|
457
|
+
payment_status_not_in?: string[] | undefined;
|
|
458
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
459
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
460
|
+
time_range?: {
|
|
461
|
+
start: string;
|
|
462
|
+
end: string;
|
|
463
|
+
} | undefined;
|
|
326
464
|
}>;
|
|
327
465
|
}, "strip", z.ZodTypeAny, {
|
|
328
466
|
appointment: {
|
|
@@ -339,6 +477,20 @@ export declare const zAutomationSelectionSchema: z.ZodDiscriminatedUnion<"target
|
|
|
339
477
|
insurance_names?: string[] | undefined;
|
|
340
478
|
address_names?: string[] | undefined;
|
|
341
479
|
payment_status_in?: string[] | undefined;
|
|
480
|
+
status_not_in?: string[] | undefined;
|
|
481
|
+
status_base_not_in?: string[] | undefined;
|
|
482
|
+
appointment_type_in?: string[] | undefined;
|
|
483
|
+
professional_names_not_in?: string[] | undefined;
|
|
484
|
+
procedure_names_not_in?: string[] | undefined;
|
|
485
|
+
insurance_names_not_in?: string[] | undefined;
|
|
486
|
+
address_names_not_in?: string[] | undefined;
|
|
487
|
+
payment_status_not_in?: string[] | undefined;
|
|
488
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
489
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
490
|
+
time_range?: {
|
|
491
|
+
start: string;
|
|
492
|
+
end: string;
|
|
493
|
+
} | undefined;
|
|
342
494
|
};
|
|
343
495
|
target: "appointment";
|
|
344
496
|
}, {
|
|
@@ -356,6 +508,20 @@ export declare const zAutomationSelectionSchema: z.ZodDiscriminatedUnion<"target
|
|
|
356
508
|
insurance_names?: string[] | undefined;
|
|
357
509
|
address_names?: string[] | undefined;
|
|
358
510
|
payment_status_in?: string[] | undefined;
|
|
511
|
+
status_not_in?: string[] | undefined;
|
|
512
|
+
status_base_not_in?: string[] | undefined;
|
|
513
|
+
appointment_type_in?: string[] | undefined;
|
|
514
|
+
professional_names_not_in?: string[] | undefined;
|
|
515
|
+
procedure_names_not_in?: string[] | undefined;
|
|
516
|
+
insurance_names_not_in?: string[] | undefined;
|
|
517
|
+
address_names_not_in?: string[] | undefined;
|
|
518
|
+
payment_status_not_in?: string[] | undefined;
|
|
519
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
520
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
521
|
+
time_range?: {
|
|
522
|
+
start: string;
|
|
523
|
+
end: string;
|
|
524
|
+
} | undefined;
|
|
359
525
|
};
|
|
360
526
|
target: "appointment";
|
|
361
527
|
}>, z.ZodObject<{
|
|
@@ -2480,6 +2646,32 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
2480
2646
|
insurance_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2481
2647
|
address_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2482
2648
|
payment_status_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2649
|
+
status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2650
|
+
status_base_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2651
|
+
appointment_type_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2652
|
+
professional_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2653
|
+
procedure_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2654
|
+
insurance_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2655
|
+
address_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2656
|
+
payment_status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
2657
|
+
appointment_mode_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
2658
|
+
appointment_mode_not_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
2659
|
+
time_range: z.ZodOptional<z.ZodEffects<z.ZodObject<{
|
|
2660
|
+
start: z.ZodString;
|
|
2661
|
+
end: z.ZodString;
|
|
2662
|
+
}, "strip", z.ZodTypeAny, {
|
|
2663
|
+
start: string;
|
|
2664
|
+
end: string;
|
|
2665
|
+
}, {
|
|
2666
|
+
start: string;
|
|
2667
|
+
end: string;
|
|
2668
|
+
}>, {
|
|
2669
|
+
start: string;
|
|
2670
|
+
end: string;
|
|
2671
|
+
}, {
|
|
2672
|
+
start: string;
|
|
2673
|
+
end: string;
|
|
2674
|
+
}>>;
|
|
2483
2675
|
}, "strip", z.ZodTypeAny, {
|
|
2484
2676
|
date_window: {
|
|
2485
2677
|
offset_days: number;
|
|
@@ -2494,6 +2686,20 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
2494
2686
|
insurance_names?: string[] | undefined;
|
|
2495
2687
|
address_names?: string[] | undefined;
|
|
2496
2688
|
payment_status_in?: string[] | undefined;
|
|
2689
|
+
status_not_in?: string[] | undefined;
|
|
2690
|
+
status_base_not_in?: string[] | undefined;
|
|
2691
|
+
appointment_type_in?: string[] | undefined;
|
|
2692
|
+
professional_names_not_in?: string[] | undefined;
|
|
2693
|
+
procedure_names_not_in?: string[] | undefined;
|
|
2694
|
+
insurance_names_not_in?: string[] | undefined;
|
|
2695
|
+
address_names_not_in?: string[] | undefined;
|
|
2696
|
+
payment_status_not_in?: string[] | undefined;
|
|
2697
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2698
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2699
|
+
time_range?: {
|
|
2700
|
+
start: string;
|
|
2701
|
+
end: string;
|
|
2702
|
+
} | undefined;
|
|
2497
2703
|
}, {
|
|
2498
2704
|
date_window: {
|
|
2499
2705
|
offset_days: number;
|
|
@@ -2508,6 +2714,20 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
2508
2714
|
insurance_names?: string[] | undefined;
|
|
2509
2715
|
address_names?: string[] | undefined;
|
|
2510
2716
|
payment_status_in?: string[] | undefined;
|
|
2717
|
+
status_not_in?: string[] | undefined;
|
|
2718
|
+
status_base_not_in?: string[] | undefined;
|
|
2719
|
+
appointment_type_in?: string[] | undefined;
|
|
2720
|
+
professional_names_not_in?: string[] | undefined;
|
|
2721
|
+
procedure_names_not_in?: string[] | undefined;
|
|
2722
|
+
insurance_names_not_in?: string[] | undefined;
|
|
2723
|
+
address_names_not_in?: string[] | undefined;
|
|
2724
|
+
payment_status_not_in?: string[] | undefined;
|
|
2725
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2726
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2727
|
+
time_range?: {
|
|
2728
|
+
start: string;
|
|
2729
|
+
end: string;
|
|
2730
|
+
} | undefined;
|
|
2511
2731
|
}>;
|
|
2512
2732
|
}, "strip", z.ZodTypeAny, {
|
|
2513
2733
|
appointment: {
|
|
@@ -2524,6 +2744,20 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
2524
2744
|
insurance_names?: string[] | undefined;
|
|
2525
2745
|
address_names?: string[] | undefined;
|
|
2526
2746
|
payment_status_in?: string[] | undefined;
|
|
2747
|
+
status_not_in?: string[] | undefined;
|
|
2748
|
+
status_base_not_in?: string[] | undefined;
|
|
2749
|
+
appointment_type_in?: string[] | undefined;
|
|
2750
|
+
professional_names_not_in?: string[] | undefined;
|
|
2751
|
+
procedure_names_not_in?: string[] | undefined;
|
|
2752
|
+
insurance_names_not_in?: string[] | undefined;
|
|
2753
|
+
address_names_not_in?: string[] | undefined;
|
|
2754
|
+
payment_status_not_in?: string[] | undefined;
|
|
2755
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2756
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2757
|
+
time_range?: {
|
|
2758
|
+
start: string;
|
|
2759
|
+
end: string;
|
|
2760
|
+
} | undefined;
|
|
2527
2761
|
};
|
|
2528
2762
|
target: "appointment";
|
|
2529
2763
|
}, {
|
|
@@ -2541,6 +2775,20 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
2541
2775
|
insurance_names?: string[] | undefined;
|
|
2542
2776
|
address_names?: string[] | undefined;
|
|
2543
2777
|
payment_status_in?: string[] | undefined;
|
|
2778
|
+
status_not_in?: string[] | undefined;
|
|
2779
|
+
status_base_not_in?: string[] | undefined;
|
|
2780
|
+
appointment_type_in?: string[] | undefined;
|
|
2781
|
+
professional_names_not_in?: string[] | undefined;
|
|
2782
|
+
procedure_names_not_in?: string[] | undefined;
|
|
2783
|
+
insurance_names_not_in?: string[] | undefined;
|
|
2784
|
+
address_names_not_in?: string[] | undefined;
|
|
2785
|
+
payment_status_not_in?: string[] | undefined;
|
|
2786
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2787
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
2788
|
+
time_range?: {
|
|
2789
|
+
start: string;
|
|
2790
|
+
end: string;
|
|
2791
|
+
} | undefined;
|
|
2544
2792
|
};
|
|
2545
2793
|
target: "appointment";
|
|
2546
2794
|
}>, z.ZodObject<{
|
|
@@ -3483,6 +3731,20 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
3483
3731
|
insurance_names?: string[] | undefined;
|
|
3484
3732
|
address_names?: string[] | undefined;
|
|
3485
3733
|
payment_status_in?: string[] | undefined;
|
|
3734
|
+
status_not_in?: string[] | undefined;
|
|
3735
|
+
status_base_not_in?: string[] | undefined;
|
|
3736
|
+
appointment_type_in?: string[] | undefined;
|
|
3737
|
+
professional_names_not_in?: string[] | undefined;
|
|
3738
|
+
procedure_names_not_in?: string[] | undefined;
|
|
3739
|
+
insurance_names_not_in?: string[] | undefined;
|
|
3740
|
+
address_names_not_in?: string[] | undefined;
|
|
3741
|
+
payment_status_not_in?: string[] | undefined;
|
|
3742
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
3743
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
3744
|
+
time_range?: {
|
|
3745
|
+
start: string;
|
|
3746
|
+
end: string;
|
|
3747
|
+
} | undefined;
|
|
3486
3748
|
};
|
|
3487
3749
|
target: "appointment";
|
|
3488
3750
|
} | {
|
|
@@ -3679,6 +3941,20 @@ export declare const zAutomationRoutineSchema: z.ZodObject<{
|
|
|
3679
3941
|
insurance_names?: string[] | undefined;
|
|
3680
3942
|
address_names?: string[] | undefined;
|
|
3681
3943
|
payment_status_in?: string[] | undefined;
|
|
3944
|
+
status_not_in?: string[] | undefined;
|
|
3945
|
+
status_base_not_in?: string[] | undefined;
|
|
3946
|
+
appointment_type_in?: string[] | undefined;
|
|
3947
|
+
professional_names_not_in?: string[] | undefined;
|
|
3948
|
+
procedure_names_not_in?: string[] | undefined;
|
|
3949
|
+
insurance_names_not_in?: string[] | undefined;
|
|
3950
|
+
address_names_not_in?: string[] | undefined;
|
|
3951
|
+
payment_status_not_in?: string[] | undefined;
|
|
3952
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
3953
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
3954
|
+
time_range?: {
|
|
3955
|
+
start: string;
|
|
3956
|
+
end: string;
|
|
3957
|
+
} | undefined;
|
|
3682
3958
|
};
|
|
3683
3959
|
target: "appointment";
|
|
3684
3960
|
} | {
|
|
@@ -3940,6 +4216,32 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
3940
4216
|
insurance_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
3941
4217
|
address_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
3942
4218
|
payment_status_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4219
|
+
status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4220
|
+
status_base_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4221
|
+
appointment_type_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4222
|
+
professional_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4223
|
+
procedure_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4224
|
+
insurance_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4225
|
+
address_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4226
|
+
payment_status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
4227
|
+
appointment_mode_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
4228
|
+
appointment_mode_not_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
4229
|
+
time_range: z.ZodOptional<z.ZodEffects<z.ZodObject<{
|
|
4230
|
+
start: z.ZodString;
|
|
4231
|
+
end: z.ZodString;
|
|
4232
|
+
}, "strip", z.ZodTypeAny, {
|
|
4233
|
+
start: string;
|
|
4234
|
+
end: string;
|
|
4235
|
+
}, {
|
|
4236
|
+
start: string;
|
|
4237
|
+
end: string;
|
|
4238
|
+
}>, {
|
|
4239
|
+
start: string;
|
|
4240
|
+
end: string;
|
|
4241
|
+
}, {
|
|
4242
|
+
start: string;
|
|
4243
|
+
end: string;
|
|
4244
|
+
}>>;
|
|
3943
4245
|
}, "strip", z.ZodTypeAny, {
|
|
3944
4246
|
date_window: {
|
|
3945
4247
|
offset_days: number;
|
|
@@ -3954,6 +4256,20 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
3954
4256
|
insurance_names?: string[] | undefined;
|
|
3955
4257
|
address_names?: string[] | undefined;
|
|
3956
4258
|
payment_status_in?: string[] | undefined;
|
|
4259
|
+
status_not_in?: string[] | undefined;
|
|
4260
|
+
status_base_not_in?: string[] | undefined;
|
|
4261
|
+
appointment_type_in?: string[] | undefined;
|
|
4262
|
+
professional_names_not_in?: string[] | undefined;
|
|
4263
|
+
procedure_names_not_in?: string[] | undefined;
|
|
4264
|
+
insurance_names_not_in?: string[] | undefined;
|
|
4265
|
+
address_names_not_in?: string[] | undefined;
|
|
4266
|
+
payment_status_not_in?: string[] | undefined;
|
|
4267
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4268
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4269
|
+
time_range?: {
|
|
4270
|
+
start: string;
|
|
4271
|
+
end: string;
|
|
4272
|
+
} | undefined;
|
|
3957
4273
|
}, {
|
|
3958
4274
|
date_window: {
|
|
3959
4275
|
offset_days: number;
|
|
@@ -3968,6 +4284,20 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
3968
4284
|
insurance_names?: string[] | undefined;
|
|
3969
4285
|
address_names?: string[] | undefined;
|
|
3970
4286
|
payment_status_in?: string[] | undefined;
|
|
4287
|
+
status_not_in?: string[] | undefined;
|
|
4288
|
+
status_base_not_in?: string[] | undefined;
|
|
4289
|
+
appointment_type_in?: string[] | undefined;
|
|
4290
|
+
professional_names_not_in?: string[] | undefined;
|
|
4291
|
+
procedure_names_not_in?: string[] | undefined;
|
|
4292
|
+
insurance_names_not_in?: string[] | undefined;
|
|
4293
|
+
address_names_not_in?: string[] | undefined;
|
|
4294
|
+
payment_status_not_in?: string[] | undefined;
|
|
4295
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4296
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4297
|
+
time_range?: {
|
|
4298
|
+
start: string;
|
|
4299
|
+
end: string;
|
|
4300
|
+
} | undefined;
|
|
3971
4301
|
}>;
|
|
3972
4302
|
}, "strip", z.ZodTypeAny, {
|
|
3973
4303
|
appointment: {
|
|
@@ -3984,6 +4314,20 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
3984
4314
|
insurance_names?: string[] | undefined;
|
|
3985
4315
|
address_names?: string[] | undefined;
|
|
3986
4316
|
payment_status_in?: string[] | undefined;
|
|
4317
|
+
status_not_in?: string[] | undefined;
|
|
4318
|
+
status_base_not_in?: string[] | undefined;
|
|
4319
|
+
appointment_type_in?: string[] | undefined;
|
|
4320
|
+
professional_names_not_in?: string[] | undefined;
|
|
4321
|
+
procedure_names_not_in?: string[] | undefined;
|
|
4322
|
+
insurance_names_not_in?: string[] | undefined;
|
|
4323
|
+
address_names_not_in?: string[] | undefined;
|
|
4324
|
+
payment_status_not_in?: string[] | undefined;
|
|
4325
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4326
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4327
|
+
time_range?: {
|
|
4328
|
+
start: string;
|
|
4329
|
+
end: string;
|
|
4330
|
+
} | undefined;
|
|
3987
4331
|
};
|
|
3988
4332
|
target: "appointment";
|
|
3989
4333
|
}, {
|
|
@@ -4001,6 +4345,20 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
4001
4345
|
insurance_names?: string[] | undefined;
|
|
4002
4346
|
address_names?: string[] | undefined;
|
|
4003
4347
|
payment_status_in?: string[] | undefined;
|
|
4348
|
+
status_not_in?: string[] | undefined;
|
|
4349
|
+
status_base_not_in?: string[] | undefined;
|
|
4350
|
+
appointment_type_in?: string[] | undefined;
|
|
4351
|
+
professional_names_not_in?: string[] | undefined;
|
|
4352
|
+
procedure_names_not_in?: string[] | undefined;
|
|
4353
|
+
insurance_names_not_in?: string[] | undefined;
|
|
4354
|
+
address_names_not_in?: string[] | undefined;
|
|
4355
|
+
payment_status_not_in?: string[] | undefined;
|
|
4356
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4357
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
4358
|
+
time_range?: {
|
|
4359
|
+
start: string;
|
|
4360
|
+
end: string;
|
|
4361
|
+
} | undefined;
|
|
4004
4362
|
};
|
|
4005
4363
|
target: "appointment";
|
|
4006
4364
|
}>, z.ZodObject<{
|
|
@@ -4905,6 +5263,20 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
4905
5263
|
insurance_names?: string[] | undefined;
|
|
4906
5264
|
address_names?: string[] | undefined;
|
|
4907
5265
|
payment_status_in?: string[] | undefined;
|
|
5266
|
+
status_not_in?: string[] | undefined;
|
|
5267
|
+
status_base_not_in?: string[] | undefined;
|
|
5268
|
+
appointment_type_in?: string[] | undefined;
|
|
5269
|
+
professional_names_not_in?: string[] | undefined;
|
|
5270
|
+
procedure_names_not_in?: string[] | undefined;
|
|
5271
|
+
insurance_names_not_in?: string[] | undefined;
|
|
5272
|
+
address_names_not_in?: string[] | undefined;
|
|
5273
|
+
payment_status_not_in?: string[] | undefined;
|
|
5274
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5275
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5276
|
+
time_range?: {
|
|
5277
|
+
start: string;
|
|
5278
|
+
end: string;
|
|
5279
|
+
} | undefined;
|
|
4908
5280
|
};
|
|
4909
5281
|
target: "appointment";
|
|
4910
5282
|
} | {
|
|
@@ -5086,6 +5458,20 @@ export declare const zAutomationRoutineWriteSchema: z.ZodObject<{
|
|
|
5086
5458
|
insurance_names?: string[] | undefined;
|
|
5087
5459
|
address_names?: string[] | undefined;
|
|
5088
5460
|
payment_status_in?: string[] | undefined;
|
|
5461
|
+
status_not_in?: string[] | undefined;
|
|
5462
|
+
status_base_not_in?: string[] | undefined;
|
|
5463
|
+
appointment_type_in?: string[] | undefined;
|
|
5464
|
+
professional_names_not_in?: string[] | undefined;
|
|
5465
|
+
procedure_names_not_in?: string[] | undefined;
|
|
5466
|
+
insurance_names_not_in?: string[] | undefined;
|
|
5467
|
+
address_names_not_in?: string[] | undefined;
|
|
5468
|
+
payment_status_not_in?: string[] | undefined;
|
|
5469
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5470
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5471
|
+
time_range?: {
|
|
5472
|
+
start: string;
|
|
5473
|
+
end: string;
|
|
5474
|
+
} | undefined;
|
|
5089
5475
|
};
|
|
5090
5476
|
target: "appointment";
|
|
5091
5477
|
} | {
|
|
@@ -5334,6 +5720,32 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
5334
5720
|
insurance_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5335
5721
|
address_names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5336
5722
|
payment_status_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5723
|
+
status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5724
|
+
status_base_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5725
|
+
appointment_type_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5726
|
+
professional_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5727
|
+
procedure_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5728
|
+
insurance_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5729
|
+
address_names_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5730
|
+
payment_status_not_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
5731
|
+
appointment_mode_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
5732
|
+
appointment_mode_not_in: z.ZodOptional<z.ZodArray<z.ZodEnum<["telemedicine", "in_person"]>, "many">>;
|
|
5733
|
+
time_range: z.ZodOptional<z.ZodEffects<z.ZodObject<{
|
|
5734
|
+
start: z.ZodString;
|
|
5735
|
+
end: z.ZodString;
|
|
5736
|
+
}, "strip", z.ZodTypeAny, {
|
|
5737
|
+
start: string;
|
|
5738
|
+
end: string;
|
|
5739
|
+
}, {
|
|
5740
|
+
start: string;
|
|
5741
|
+
end: string;
|
|
5742
|
+
}>, {
|
|
5743
|
+
start: string;
|
|
5744
|
+
end: string;
|
|
5745
|
+
}, {
|
|
5746
|
+
start: string;
|
|
5747
|
+
end: string;
|
|
5748
|
+
}>>;
|
|
5337
5749
|
}, "strip", z.ZodTypeAny, {
|
|
5338
5750
|
date_window: {
|
|
5339
5751
|
offset_days: number;
|
|
@@ -5348,6 +5760,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
5348
5760
|
insurance_names?: string[] | undefined;
|
|
5349
5761
|
address_names?: string[] | undefined;
|
|
5350
5762
|
payment_status_in?: string[] | undefined;
|
|
5763
|
+
status_not_in?: string[] | undefined;
|
|
5764
|
+
status_base_not_in?: string[] | undefined;
|
|
5765
|
+
appointment_type_in?: string[] | undefined;
|
|
5766
|
+
professional_names_not_in?: string[] | undefined;
|
|
5767
|
+
procedure_names_not_in?: string[] | undefined;
|
|
5768
|
+
insurance_names_not_in?: string[] | undefined;
|
|
5769
|
+
address_names_not_in?: string[] | undefined;
|
|
5770
|
+
payment_status_not_in?: string[] | undefined;
|
|
5771
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5772
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5773
|
+
time_range?: {
|
|
5774
|
+
start: string;
|
|
5775
|
+
end: string;
|
|
5776
|
+
} | undefined;
|
|
5351
5777
|
}, {
|
|
5352
5778
|
date_window: {
|
|
5353
5779
|
offset_days: number;
|
|
@@ -5362,6 +5788,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
5362
5788
|
insurance_names?: string[] | undefined;
|
|
5363
5789
|
address_names?: string[] | undefined;
|
|
5364
5790
|
payment_status_in?: string[] | undefined;
|
|
5791
|
+
status_not_in?: string[] | undefined;
|
|
5792
|
+
status_base_not_in?: string[] | undefined;
|
|
5793
|
+
appointment_type_in?: string[] | undefined;
|
|
5794
|
+
professional_names_not_in?: string[] | undefined;
|
|
5795
|
+
procedure_names_not_in?: string[] | undefined;
|
|
5796
|
+
insurance_names_not_in?: string[] | undefined;
|
|
5797
|
+
address_names_not_in?: string[] | undefined;
|
|
5798
|
+
payment_status_not_in?: string[] | undefined;
|
|
5799
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5800
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5801
|
+
time_range?: {
|
|
5802
|
+
start: string;
|
|
5803
|
+
end: string;
|
|
5804
|
+
} | undefined;
|
|
5365
5805
|
}>;
|
|
5366
5806
|
}, "strip", z.ZodTypeAny, {
|
|
5367
5807
|
appointment: {
|
|
@@ -5378,6 +5818,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
5378
5818
|
insurance_names?: string[] | undefined;
|
|
5379
5819
|
address_names?: string[] | undefined;
|
|
5380
5820
|
payment_status_in?: string[] | undefined;
|
|
5821
|
+
status_not_in?: string[] | undefined;
|
|
5822
|
+
status_base_not_in?: string[] | undefined;
|
|
5823
|
+
appointment_type_in?: string[] | undefined;
|
|
5824
|
+
professional_names_not_in?: string[] | undefined;
|
|
5825
|
+
procedure_names_not_in?: string[] | undefined;
|
|
5826
|
+
insurance_names_not_in?: string[] | undefined;
|
|
5827
|
+
address_names_not_in?: string[] | undefined;
|
|
5828
|
+
payment_status_not_in?: string[] | undefined;
|
|
5829
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5830
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5831
|
+
time_range?: {
|
|
5832
|
+
start: string;
|
|
5833
|
+
end: string;
|
|
5834
|
+
} | undefined;
|
|
5381
5835
|
};
|
|
5382
5836
|
target: "appointment";
|
|
5383
5837
|
}, {
|
|
@@ -5395,6 +5849,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
5395
5849
|
insurance_names?: string[] | undefined;
|
|
5396
5850
|
address_names?: string[] | undefined;
|
|
5397
5851
|
payment_status_in?: string[] | undefined;
|
|
5852
|
+
status_not_in?: string[] | undefined;
|
|
5853
|
+
status_base_not_in?: string[] | undefined;
|
|
5854
|
+
appointment_type_in?: string[] | undefined;
|
|
5855
|
+
professional_names_not_in?: string[] | undefined;
|
|
5856
|
+
procedure_names_not_in?: string[] | undefined;
|
|
5857
|
+
insurance_names_not_in?: string[] | undefined;
|
|
5858
|
+
address_names_not_in?: string[] | undefined;
|
|
5859
|
+
payment_status_not_in?: string[] | undefined;
|
|
5860
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5861
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
5862
|
+
time_range?: {
|
|
5863
|
+
start: string;
|
|
5864
|
+
end: string;
|
|
5865
|
+
} | undefined;
|
|
5398
5866
|
};
|
|
5399
5867
|
target: "appointment";
|
|
5400
5868
|
}>, z.ZodObject<{
|
|
@@ -6299,6 +6767,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
6299
6767
|
insurance_names?: string[] | undefined;
|
|
6300
6768
|
address_names?: string[] | undefined;
|
|
6301
6769
|
payment_status_in?: string[] | undefined;
|
|
6770
|
+
status_not_in?: string[] | undefined;
|
|
6771
|
+
status_base_not_in?: string[] | undefined;
|
|
6772
|
+
appointment_type_in?: string[] | undefined;
|
|
6773
|
+
professional_names_not_in?: string[] | undefined;
|
|
6774
|
+
procedure_names_not_in?: string[] | undefined;
|
|
6775
|
+
insurance_names_not_in?: string[] | undefined;
|
|
6776
|
+
address_names_not_in?: string[] | undefined;
|
|
6777
|
+
payment_status_not_in?: string[] | undefined;
|
|
6778
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
6779
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
6780
|
+
time_range?: {
|
|
6781
|
+
start: string;
|
|
6782
|
+
end: string;
|
|
6783
|
+
} | undefined;
|
|
6302
6784
|
};
|
|
6303
6785
|
target: "appointment";
|
|
6304
6786
|
} | {
|
|
@@ -6480,6 +6962,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
6480
6962
|
insurance_names?: string[] | undefined;
|
|
6481
6963
|
address_names?: string[] | undefined;
|
|
6482
6964
|
payment_status_in?: string[] | undefined;
|
|
6965
|
+
status_not_in?: string[] | undefined;
|
|
6966
|
+
status_base_not_in?: string[] | undefined;
|
|
6967
|
+
appointment_type_in?: string[] | undefined;
|
|
6968
|
+
professional_names_not_in?: string[] | undefined;
|
|
6969
|
+
procedure_names_not_in?: string[] | undefined;
|
|
6970
|
+
insurance_names_not_in?: string[] | undefined;
|
|
6971
|
+
address_names_not_in?: string[] | undefined;
|
|
6972
|
+
payment_status_not_in?: string[] | undefined;
|
|
6973
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
6974
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
6975
|
+
time_range?: {
|
|
6976
|
+
start: string;
|
|
6977
|
+
end: string;
|
|
6978
|
+
} | undefined;
|
|
6483
6979
|
};
|
|
6484
6980
|
target: "appointment";
|
|
6485
6981
|
} | {
|
|
@@ -6666,6 +7162,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
6666
7162
|
insurance_names?: string[] | undefined;
|
|
6667
7163
|
address_names?: string[] | undefined;
|
|
6668
7164
|
payment_status_in?: string[] | undefined;
|
|
7165
|
+
status_not_in?: string[] | undefined;
|
|
7166
|
+
status_base_not_in?: string[] | undefined;
|
|
7167
|
+
appointment_type_in?: string[] | undefined;
|
|
7168
|
+
professional_names_not_in?: string[] | undefined;
|
|
7169
|
+
procedure_names_not_in?: string[] | undefined;
|
|
7170
|
+
insurance_names_not_in?: string[] | undefined;
|
|
7171
|
+
address_names_not_in?: string[] | undefined;
|
|
7172
|
+
payment_status_not_in?: string[] | undefined;
|
|
7173
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
7174
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
7175
|
+
time_range?: {
|
|
7176
|
+
start: string;
|
|
7177
|
+
end: string;
|
|
7178
|
+
} | undefined;
|
|
6669
7179
|
};
|
|
6670
7180
|
target: "appointment";
|
|
6671
7181
|
} | {
|
|
@@ -6850,6 +7360,20 @@ export declare const zAutomationRoutineUpdateRequestSchema: z.ZodObject<{
|
|
|
6850
7360
|
insurance_names?: string[] | undefined;
|
|
6851
7361
|
address_names?: string[] | undefined;
|
|
6852
7362
|
payment_status_in?: string[] | undefined;
|
|
7363
|
+
status_not_in?: string[] | undefined;
|
|
7364
|
+
status_base_not_in?: string[] | undefined;
|
|
7365
|
+
appointment_type_in?: string[] | undefined;
|
|
7366
|
+
professional_names_not_in?: string[] | undefined;
|
|
7367
|
+
procedure_names_not_in?: string[] | undefined;
|
|
7368
|
+
insurance_names_not_in?: string[] | undefined;
|
|
7369
|
+
address_names_not_in?: string[] | undefined;
|
|
7370
|
+
payment_status_not_in?: string[] | undefined;
|
|
7371
|
+
appointment_mode_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
7372
|
+
appointment_mode_not_in?: ("telemedicine" | "in_person")[] | undefined;
|
|
7373
|
+
time_range?: {
|
|
7374
|
+
start: string;
|
|
7375
|
+
end: string;
|
|
7376
|
+
} | undefined;
|
|
6853
7377
|
};
|
|
6854
7378
|
target: "appointment";
|
|
6855
7379
|
} | {
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
exports.zAutomationTriggerRequestSchema = exports.zAutomationDryRunRequestSchema = exports.zHubAutomationConfigSchema = exports.zAutomationRoutineUpdateRequestSchema = exports.zAutomationRoutineWriteSchema = exports.zAutomationRoutineSchema = exports.zAutomationBranchModeSchema = exports.zAutomationBranchSchema = exports.zAutomationOutputSchema = exports.zAutomationActionOutputSchema = exports.zAutomationHumanTaskOutputSchema = exports.zAutomationAutoTaskOutputSchema = exports.zAutomationExecuteAtSchema = exports.zAutomationConditionGroupSchema = exports.zAutomationConditionSchema = exports.zAutomationOperatorSchema = exports.zAutomationSelectionSchema = exports.zAutomationPatientSelectionSchema = exports.zAutomationLeadSelectionSchema = exports.zAutomationAppointmentSelectionSchema = exports.zAutomationDateWindowSchema = exports.zAutomationDateOffsetModeSchema = exports.zAutomationTriggerSchema = exports.zAutomationEventTriggerSchema = exports.zAutomationWebhookTriggerSchema = exports.zAutomationCronTriggerSchema = void 0;
|
|
3
|
+
exports.zAutomationTriggerRequestSchema = exports.zAutomationDryRunRequestSchema = exports.zHubAutomationConfigSchema = exports.zAutomationRoutineUpdateRequestSchema = exports.zAutomationRoutineWriteSchema = exports.zAutomationRoutineSchema = exports.zAutomationBranchModeSchema = exports.zAutomationBranchSchema = exports.zAutomationOutputSchema = exports.zAutomationActionOutputSchema = exports.zAutomationHumanTaskOutputSchema = exports.zAutomationAutoTaskOutputSchema = exports.zAutomationExecuteAtSchema = exports.zAutomationConditionGroupSchema = exports.zAutomationConditionSchema = exports.zAutomationOperatorSchema = exports.zAutomationSelectionSchema = exports.zAutomationPatientSelectionSchema = exports.zAutomationLeadSelectionSchema = exports.zAutomationAppointmentSelectionSchema = exports.zAutomationAppointmentModeSchema = exports.zAutomationTimeOfDaySchema = exports.zAutomationDateWindowSchema = exports.zAutomationDateOffsetModeSchema = exports.zAutomationTriggerSchema = exports.zAutomationEventTriggerSchema = exports.zAutomationWebhookTriggerSchema = exports.zAutomationCronTriggerSchema = void 0;
|
|
4
4
|
const zod_1 = require("zod");
|
|
5
5
|
const zod_schemas_1 = require("../evo-task/zod-schemas");
|
|
6
6
|
// ------------------------------------------------------
|
|
@@ -41,6 +41,16 @@ exports.zAutomationDateWindowSchema = zod_1.z.object({
|
|
|
41
41
|
offset_days: zod_1.z.number().int(), // may be negative (retroactive routines)
|
|
42
42
|
offset_mode: exports.zAutomationDateOffsetModeSchema,
|
|
43
43
|
});
|
|
44
|
+
// feat-147: HH:mm (24h) — same shape as zAutomationExecuteAtSchema's `time`.
|
|
45
|
+
exports.zAutomationTimeOfDaySchema = zod_1.z
|
|
46
|
+
.string()
|
|
47
|
+
.regex(/^([01]\d|2[0-3]):[0-5]\d$/, "expected HH:mm");
|
|
48
|
+
// feat-147: appointment modality (IAppointment.appointmentMode). Fixed enum —
|
|
49
|
+
// the selection matches it exactly (no wildcard glob).
|
|
50
|
+
exports.zAutomationAppointmentModeSchema = zod_1.z.enum([
|
|
51
|
+
"telemedicine",
|
|
52
|
+
"in_person",
|
|
53
|
+
]);
|
|
44
54
|
exports.zAutomationAppointmentSelectionSchema = zod_1.z.object({
|
|
45
55
|
target: zod_1.z.literal("appointment"),
|
|
46
56
|
appointment: zod_1.z.object({
|
|
@@ -56,6 +66,31 @@ exports.zAutomationAppointmentSelectionSchema = zod_1.z.object({
|
|
|
56
66
|
insurance_names: zod_1.z.array(zod_1.z.string()).optional(),
|
|
57
67
|
address_names: zod_1.z.array(zod_1.z.string()).optional(),
|
|
58
68
|
payment_status_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
69
|
+
// ---- feat-147 (all optional => persisted routines stay valid).
|
|
70
|
+
status_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
71
|
+
status_base_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
72
|
+
appointment_type_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
73
|
+
professional_names_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
74
|
+
procedure_names_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
75
|
+
insurance_names_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
76
|
+
address_names_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
77
|
+
payment_status_not_in: zod_1.z.array(zod_1.z.string()).optional(),
|
|
78
|
+
// Fixed enum, exact match (no glob).
|
|
79
|
+
appointment_mode_in: zod_1.z.array(exports.zAutomationAppointmentModeSchema).optional(),
|
|
80
|
+
appointment_mode_not_in: zod_1.z
|
|
81
|
+
.array(exports.zAutomationAppointmentModeSchema)
|
|
82
|
+
.optional(),
|
|
83
|
+
// Local-time window over startDate in the tenant timezone;
|
|
84
|
+
// `start <= hh:mm < end`, inverted range = overnight wraparound.
|
|
85
|
+
time_range: zod_1.z
|
|
86
|
+
.object({
|
|
87
|
+
start: exports.zAutomationTimeOfDaySchema,
|
|
88
|
+
end: exports.zAutomationTimeOfDaySchema,
|
|
89
|
+
})
|
|
90
|
+
.refine((r) => r.start !== r.end, {
|
|
91
|
+
message: "time_range.start and time_range.end must differ",
|
|
92
|
+
})
|
|
93
|
+
.optional(),
|
|
59
94
|
}),
|
|
60
95
|
});
|
|
61
96
|
// feat-085 (F3): lead/patient selections (domain-event targets). The `target`
|
|
@@ -49,6 +49,18 @@ export const zAutomationDateWindowSchema = z.object({
|
|
|
49
49
|
offset_mode: zAutomationDateOffsetModeSchema,
|
|
50
50
|
});
|
|
51
51
|
|
|
52
|
+
// feat-147: HH:mm (24h) — same shape as zAutomationExecuteAtSchema's `time`.
|
|
53
|
+
export const zAutomationTimeOfDaySchema = z
|
|
54
|
+
.string()
|
|
55
|
+
.regex(/^([01]\d|2[0-3]):[0-5]\d$/, "expected HH:mm");
|
|
56
|
+
|
|
57
|
+
// feat-147: appointment modality (IAppointment.appointmentMode). Fixed enum —
|
|
58
|
+
// the selection matches it exactly (no wildcard glob).
|
|
59
|
+
export const zAutomationAppointmentModeSchema = z.enum([
|
|
60
|
+
"telemedicine",
|
|
61
|
+
"in_person",
|
|
62
|
+
]);
|
|
63
|
+
|
|
52
64
|
export const zAutomationAppointmentSelectionSchema = z.object({
|
|
53
65
|
target: z.literal("appointment"),
|
|
54
66
|
appointment: z.object({
|
|
@@ -64,6 +76,32 @@ export const zAutomationAppointmentSelectionSchema = z.object({
|
|
|
64
76
|
insurance_names: z.array(z.string()).optional(),
|
|
65
77
|
address_names: z.array(z.string()).optional(),
|
|
66
78
|
payment_status_in: z.array(z.string()).optional(),
|
|
79
|
+
|
|
80
|
+
// ---- feat-147 (all optional => persisted routines stay valid).
|
|
81
|
+
status_not_in: z.array(z.string()).optional(),
|
|
82
|
+
status_base_not_in: z.array(z.string()).optional(),
|
|
83
|
+
appointment_type_in: z.array(z.string()).optional(),
|
|
84
|
+
professional_names_not_in: z.array(z.string()).optional(),
|
|
85
|
+
procedure_names_not_in: z.array(z.string()).optional(),
|
|
86
|
+
insurance_names_not_in: z.array(z.string()).optional(),
|
|
87
|
+
address_names_not_in: z.array(z.string()).optional(),
|
|
88
|
+
payment_status_not_in: z.array(z.string()).optional(),
|
|
89
|
+
// Fixed enum, exact match (no glob).
|
|
90
|
+
appointment_mode_in: z.array(zAutomationAppointmentModeSchema).optional(),
|
|
91
|
+
appointment_mode_not_in: z
|
|
92
|
+
.array(zAutomationAppointmentModeSchema)
|
|
93
|
+
.optional(),
|
|
94
|
+
// Local-time window over startDate in the tenant timezone;
|
|
95
|
+
// `start <= hh:mm < end`, inverted range = overnight wraparound.
|
|
96
|
+
time_range: z
|
|
97
|
+
.object({
|
|
98
|
+
start: zAutomationTimeOfDaySchema,
|
|
99
|
+
end: zAutomationTimeOfDaySchema,
|
|
100
|
+
})
|
|
101
|
+
.refine((r) => r.start !== r.end, {
|
|
102
|
+
message: "time_range.start and time_range.end must differ",
|
|
103
|
+
})
|
|
104
|
+
.optional(),
|
|
67
105
|
}),
|
|
68
106
|
});
|
|
69
107
|
|
|
@@ -41,6 +41,20 @@ export interface IAutomationAppointmentSelection {
|
|
|
41
41
|
insurance_names?: string[];
|
|
42
42
|
address_names?: string[];
|
|
43
43
|
payment_status_in?: string[];
|
|
44
|
+
status_not_in?: string[];
|
|
45
|
+
status_base_not_in?: string[];
|
|
46
|
+
appointment_type_in?: string[];
|
|
47
|
+
professional_names_not_in?: string[];
|
|
48
|
+
procedure_names_not_in?: string[];
|
|
49
|
+
insurance_names_not_in?: string[];
|
|
50
|
+
address_names_not_in?: string[];
|
|
51
|
+
payment_status_not_in?: string[];
|
|
52
|
+
appointment_mode_in?: string[];
|
|
53
|
+
appointment_mode_not_in?: string[];
|
|
54
|
+
time_range?: {
|
|
55
|
+
start: string;
|
|
56
|
+
end: string;
|
|
57
|
+
};
|
|
44
58
|
};
|
|
45
59
|
}
|
|
46
60
|
export interface IAutomationLeadSelection {
|
|
@@ -250,3 +264,15 @@ export interface IAutomationRunTrace {
|
|
|
250
264
|
};
|
|
251
265
|
duration_ms: number;
|
|
252
266
|
}
|
|
267
|
+
export interface IAutomationSelectedTargetProjection {
|
|
268
|
+
appointment_id: string;
|
|
269
|
+
calendar_id: string;
|
|
270
|
+
target_date: string;
|
|
271
|
+
start_date?: string;
|
|
272
|
+
patient_name?: string;
|
|
273
|
+
professional_name?: string;
|
|
274
|
+
status?: string;
|
|
275
|
+
status_base?: string;
|
|
276
|
+
appointment_mode?: string;
|
|
277
|
+
address_name?: string;
|
|
278
|
+
}
|
|
@@ -106,6 +106,36 @@ export interface IAutomationAppointmentSelection {
|
|
|
106
106
|
address_names?: string[];
|
|
107
107
|
// payment.status — fixed local enum (pending/partial/paid/not_informed)
|
|
108
108
|
payment_status_in?: string[];
|
|
109
|
+
|
|
110
|
+
// ---- feat-147: negation mirrors + missing positive + mode + time range.
|
|
111
|
+
// All optional and additive: persisted routines stay valid as-is.
|
|
112
|
+
//
|
|
113
|
+
// Absence rule (same for every list filter): with a POSITIVE filter active,
|
|
114
|
+
// an appointment missing the field does NOT match (excluded); with a
|
|
115
|
+
// NEGATIVE filter active, it passes. Positive and negative on the same
|
|
116
|
+
// field are ANDed.
|
|
117
|
+
status_not_in?: string[];
|
|
118
|
+
status_base_not_in?: string[];
|
|
119
|
+
// appointmentBaseType — positive counterpart of appointment_type_not_in
|
|
120
|
+
appointment_type_in?: string[];
|
|
121
|
+
professional_names_not_in?: string[];
|
|
122
|
+
// excludes if ANY procedures[].name matches (mirror of procedure_names)
|
|
123
|
+
procedure_names_not_in?: string[];
|
|
124
|
+
insurance_names_not_in?: string[];
|
|
125
|
+
address_names_not_in?: string[];
|
|
126
|
+
payment_status_not_in?: string[];
|
|
127
|
+
// appointmentMode — fixed enum (telemedicine/in_person); EXACT match, no
|
|
128
|
+
// wildcard glob (same style as payment_status_in).
|
|
129
|
+
appointment_mode_in?: string[];
|
|
130
|
+
appointment_mode_not_in?: string[];
|
|
131
|
+
// Local-time window over appointment.startDate, evaluated in the TENANT
|
|
132
|
+
// timezone. Boundaries: `start <= hh:mm < end` (start inclusive, end
|
|
133
|
+
// exclusive) so adjacent ranges (08–12, 12–18) partition the day without
|
|
134
|
+
// overlap. An INVERTED range (start > end, e.g. 22:00–06:00) is supported
|
|
135
|
+
// as an overnight/wraparound window: matches `hh:mm >= start OR < end`.
|
|
136
|
+
// `start === end` is invalid (rejected by zod). An appointment without a
|
|
137
|
+
// coercible startDate does not match.
|
|
138
|
+
time_range?: { start: string; end: string };
|
|
109
139
|
};
|
|
110
140
|
}
|
|
111
141
|
|
|
@@ -489,3 +519,25 @@ export interface IAutomationRunTrace {
|
|
|
489
519
|
};
|
|
490
520
|
duration_ms: number;
|
|
491
521
|
}
|
|
522
|
+
|
|
523
|
+
// feat-147: compact projection of ONE selected target, built from the embeds the
|
|
524
|
+
// selection already holds (zero extra reads).
|
|
525
|
+
//
|
|
526
|
+
// EPHEMERAL: this shape only ever travels in the HTTP RESPONSE of
|
|
527
|
+
// `POST /routines/:id/dry-run` (capped, alongside `selected_targets_total`).
|
|
528
|
+
// It is NEVER persisted in the run doc — IAutomationRunTrace keeps its counts +
|
|
529
|
+
// capped samples so the 1MB Firestore limit stays intact.
|
|
530
|
+
export interface IAutomationSelectedTargetProjection {
|
|
531
|
+
appointment_id: string;
|
|
532
|
+
calendar_id: string;
|
|
533
|
+
// yyyy-MM-dd (target date the run resolved for this appointment)
|
|
534
|
+
target_date: string;
|
|
535
|
+
// ISO 8601 instant; the client formats it in the tenant timezone.
|
|
536
|
+
start_date?: string;
|
|
537
|
+
patient_name?: string;
|
|
538
|
+
professional_name?: string;
|
|
539
|
+
status?: string;
|
|
540
|
+
status_base?: string;
|
|
541
|
+
appointment_mode?: string;
|
|
542
|
+
address_name?: string;
|
|
543
|
+
}
|