balendar 0.0.6 → 0.0.8
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/dist/src/modules/availability-rules/availability-rules.domain.d.ts +574 -0
- package/dist/src/modules/events/events.domain.d.ts +165 -0
- package/dist/src/modules/external-calendars/external-calendars.domain.d.ts +367 -0
- package/dist/src/modules/external-events/external-events.domain.d.ts +137 -0
- package/dist/src/orchestrators/availability/availability.domain.d.ts +143 -0
- package/package.json +2 -2
|
@@ -0,0 +1,574 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
/**
|
|
3
|
+
* Availability rule metadata schema with optional booking-related fields
|
|
4
|
+
* Differs from the base metadata schema with availability-specific fields
|
|
5
|
+
*/
|
|
6
|
+
export declare const AvailabilityRuleMetadataSchema: z.ZodObject<{
|
|
7
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
8
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
9
|
+
}, z.core.$strip>;
|
|
10
|
+
export type AvailabilityRuleMetadata = z.infer<typeof AvailabilityRuleMetadataSchema>;
|
|
11
|
+
/**
|
|
12
|
+
* Recurrence types for availability rules
|
|
13
|
+
* - one_off: Single occurrence
|
|
14
|
+
* - daily: Every day between dateRangeStart and (optional) dateRangeEnd
|
|
15
|
+
* - weekly: Specific days of week between dateRangeStart and (optional) dateRangeEnd
|
|
16
|
+
*/
|
|
17
|
+
declare const OneOff: "one_off";
|
|
18
|
+
export declare const OneOffSchema: z.ZodLiteral<"one_off">;
|
|
19
|
+
export type OneOff = typeof OneOff;
|
|
20
|
+
export declare const Repeating: readonly ["daily", "weekly"];
|
|
21
|
+
export declare const RepeatingSchema: z.ZodEnum<{
|
|
22
|
+
daily: "daily";
|
|
23
|
+
weekly: "weekly";
|
|
24
|
+
}>;
|
|
25
|
+
export type Repeating = z.infer<typeof RepeatingSchema>;
|
|
26
|
+
export declare const RecurrenceTypes: readonly ["daily", "weekly", "one_off"];
|
|
27
|
+
export declare const RecurrenceSchema: z.ZodEnum<{
|
|
28
|
+
one_off: "one_off";
|
|
29
|
+
daily: "daily";
|
|
30
|
+
weekly: "weekly";
|
|
31
|
+
}>;
|
|
32
|
+
export type Recurrence = z.infer<typeof RecurrenceSchema>;
|
|
33
|
+
/**
|
|
34
|
+
* Weekdays
|
|
35
|
+
*/
|
|
36
|
+
export declare const Weekdays: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
|
|
37
|
+
export declare const WeekdaySchema: z.ZodEnum<{
|
|
38
|
+
sunday: "sunday";
|
|
39
|
+
monday: "monday";
|
|
40
|
+
tuesday: "tuesday";
|
|
41
|
+
wednesday: "wednesday";
|
|
42
|
+
thursday: "thursday";
|
|
43
|
+
friday: "friday";
|
|
44
|
+
saturday: "saturday";
|
|
45
|
+
}>;
|
|
46
|
+
export type Weekday = z.infer<typeof WeekdaySchema>;
|
|
47
|
+
export declare const WeekdaysSchema: z.ZodArray<z.ZodEnum<{
|
|
48
|
+
sunday: "sunday";
|
|
49
|
+
monday: "monday";
|
|
50
|
+
tuesday: "tuesday";
|
|
51
|
+
wednesday: "wednesday";
|
|
52
|
+
thursday: "thursday";
|
|
53
|
+
friday: "friday";
|
|
54
|
+
saturday: "saturday";
|
|
55
|
+
}>>;
|
|
56
|
+
export type Weekdays = z.infer<typeof WeekdaysSchema>;
|
|
57
|
+
export declare const CreateOneOffAvailabilityRuleInputSchema: z.ZodObject<{
|
|
58
|
+
userId: z.ZodNumber;
|
|
59
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
60
|
+
sunday: "sunday";
|
|
61
|
+
monday: "monday";
|
|
62
|
+
tuesday: "tuesday";
|
|
63
|
+
wednesday: "wednesday";
|
|
64
|
+
thursday: "thursday";
|
|
65
|
+
friday: "friday";
|
|
66
|
+
saturday: "saturday";
|
|
67
|
+
}>>;
|
|
68
|
+
windowStartTime: z.ZodString;
|
|
69
|
+
windowEndTime: z.ZodString;
|
|
70
|
+
active: z.ZodBoolean;
|
|
71
|
+
isAvailable: z.ZodBoolean;
|
|
72
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
73
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
74
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
75
|
+
}, z.core.$strip>;
|
|
76
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
77
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
78
|
+
dateRangeStart: z.ZodDefault<z.ZodNull>;
|
|
79
|
+
dateRangeEnd: z.ZodDefault<z.ZodNull>;
|
|
80
|
+
}, z.core.$strip>;
|
|
81
|
+
export type CreateOneOffAvailabilityRuleInput = z.infer<typeof CreateOneOffAvailabilityRuleInputSchema>;
|
|
82
|
+
export declare const CreateRecurringAvailabilityRuleInputSchema: z.ZodObject<{
|
|
83
|
+
userId: z.ZodNumber;
|
|
84
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
85
|
+
sunday: "sunday";
|
|
86
|
+
monday: "monday";
|
|
87
|
+
tuesday: "tuesday";
|
|
88
|
+
wednesday: "wednesday";
|
|
89
|
+
thursday: "thursday";
|
|
90
|
+
friday: "friday";
|
|
91
|
+
saturday: "saturday";
|
|
92
|
+
}>>;
|
|
93
|
+
windowStartTime: z.ZodString;
|
|
94
|
+
windowEndTime: z.ZodString;
|
|
95
|
+
active: z.ZodBoolean;
|
|
96
|
+
isAvailable: z.ZodBoolean;
|
|
97
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
98
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
99
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
100
|
+
}, z.core.$strip>;
|
|
101
|
+
recurrence: z.ZodEnum<{
|
|
102
|
+
daily: "daily";
|
|
103
|
+
weekly: "weekly";
|
|
104
|
+
}>;
|
|
105
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
106
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
107
|
+
date: z.ZodDefault<z.ZodNull>;
|
|
108
|
+
}, z.core.$strip>;
|
|
109
|
+
export type CreateRecurringAvailabilityRuleInput = z.infer<typeof CreateRecurringAvailabilityRuleInputSchema>;
|
|
110
|
+
export declare const CreateAvailabilityRuleInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
111
|
+
userId: z.ZodNumber;
|
|
112
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
113
|
+
sunday: "sunday";
|
|
114
|
+
monday: "monday";
|
|
115
|
+
tuesday: "tuesday";
|
|
116
|
+
wednesday: "wednesday";
|
|
117
|
+
thursday: "thursday";
|
|
118
|
+
friday: "friday";
|
|
119
|
+
saturday: "saturday";
|
|
120
|
+
}>>;
|
|
121
|
+
windowStartTime: z.ZodString;
|
|
122
|
+
windowEndTime: z.ZodString;
|
|
123
|
+
active: z.ZodBoolean;
|
|
124
|
+
isAvailable: z.ZodBoolean;
|
|
125
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
126
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
127
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
128
|
+
}, z.core.$strip>;
|
|
129
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
130
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
131
|
+
dateRangeStart: z.ZodDefault<z.ZodNull>;
|
|
132
|
+
dateRangeEnd: z.ZodDefault<z.ZodNull>;
|
|
133
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
134
|
+
userId: z.ZodNumber;
|
|
135
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
136
|
+
sunday: "sunday";
|
|
137
|
+
monday: "monday";
|
|
138
|
+
tuesday: "tuesday";
|
|
139
|
+
wednesday: "wednesday";
|
|
140
|
+
thursday: "thursday";
|
|
141
|
+
friday: "friday";
|
|
142
|
+
saturday: "saturday";
|
|
143
|
+
}>>;
|
|
144
|
+
windowStartTime: z.ZodString;
|
|
145
|
+
windowEndTime: z.ZodString;
|
|
146
|
+
active: z.ZodBoolean;
|
|
147
|
+
isAvailable: z.ZodBoolean;
|
|
148
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
149
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
150
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
151
|
+
}, z.core.$strip>;
|
|
152
|
+
recurrence: z.ZodEnum<{
|
|
153
|
+
daily: "daily";
|
|
154
|
+
weekly: "weekly";
|
|
155
|
+
}>;
|
|
156
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
157
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
158
|
+
date: z.ZodDefault<z.ZodNull>;
|
|
159
|
+
}, z.core.$strip>], "recurrence">;
|
|
160
|
+
export type CreateAvailabilityRuleInput = z.infer<typeof CreateAvailabilityRuleInputSchema>;
|
|
161
|
+
export declare const OneOffAvailabilityRuleSchema: z.ZodObject<{
|
|
162
|
+
userId: z.ZodNumber;
|
|
163
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
164
|
+
sunday: "sunday";
|
|
165
|
+
monday: "monday";
|
|
166
|
+
tuesday: "tuesday";
|
|
167
|
+
wednesday: "wednesday";
|
|
168
|
+
thursday: "thursday";
|
|
169
|
+
friday: "friday";
|
|
170
|
+
saturday: "saturday";
|
|
171
|
+
}>>;
|
|
172
|
+
windowStartTime: z.ZodString;
|
|
173
|
+
windowEndTime: z.ZodString;
|
|
174
|
+
active: z.ZodBoolean;
|
|
175
|
+
isAvailable: z.ZodBoolean;
|
|
176
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
177
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
178
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
179
|
+
}, z.core.$strip>;
|
|
180
|
+
availabilityRuleId: z.ZodNumber;
|
|
181
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
182
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
183
|
+
dateRangeStart: z.ZodNull;
|
|
184
|
+
dateRangeEnd: z.ZodNull;
|
|
185
|
+
}, z.core.$strip>;
|
|
186
|
+
export type OneOffAvailabilityRule = z.infer<typeof OneOffAvailabilityRuleSchema>;
|
|
187
|
+
export declare const RecurringAvailabilityRuleSchema: z.ZodObject<{
|
|
188
|
+
userId: z.ZodNumber;
|
|
189
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
190
|
+
sunday: "sunday";
|
|
191
|
+
monday: "monday";
|
|
192
|
+
tuesday: "tuesday";
|
|
193
|
+
wednesday: "wednesday";
|
|
194
|
+
thursday: "thursday";
|
|
195
|
+
friday: "friday";
|
|
196
|
+
saturday: "saturday";
|
|
197
|
+
}>>;
|
|
198
|
+
windowStartTime: z.ZodString;
|
|
199
|
+
windowEndTime: z.ZodString;
|
|
200
|
+
active: z.ZodBoolean;
|
|
201
|
+
isAvailable: z.ZodBoolean;
|
|
202
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
203
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
204
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
205
|
+
}, z.core.$strip>;
|
|
206
|
+
availabilityRuleId: z.ZodNumber;
|
|
207
|
+
recurrence: z.ZodEnum<{
|
|
208
|
+
daily: "daily";
|
|
209
|
+
weekly: "weekly";
|
|
210
|
+
}>;
|
|
211
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
212
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
213
|
+
date: z.ZodNull;
|
|
214
|
+
}, z.core.$strip>;
|
|
215
|
+
export type RecurringAvailabilityRule = z.infer<typeof RecurringAvailabilityRuleSchema>;
|
|
216
|
+
export declare const AvailabilityRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
217
|
+
userId: z.ZodNumber;
|
|
218
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
219
|
+
sunday: "sunday";
|
|
220
|
+
monday: "monday";
|
|
221
|
+
tuesday: "tuesday";
|
|
222
|
+
wednesday: "wednesday";
|
|
223
|
+
thursday: "thursday";
|
|
224
|
+
friday: "friday";
|
|
225
|
+
saturday: "saturday";
|
|
226
|
+
}>>;
|
|
227
|
+
windowStartTime: z.ZodString;
|
|
228
|
+
windowEndTime: z.ZodString;
|
|
229
|
+
active: z.ZodBoolean;
|
|
230
|
+
isAvailable: z.ZodBoolean;
|
|
231
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
232
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
233
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
234
|
+
}, z.core.$strip>;
|
|
235
|
+
availabilityRuleId: z.ZodNumber;
|
|
236
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
237
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
238
|
+
dateRangeStart: z.ZodNull;
|
|
239
|
+
dateRangeEnd: z.ZodNull;
|
|
240
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
241
|
+
userId: z.ZodNumber;
|
|
242
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
243
|
+
sunday: "sunday";
|
|
244
|
+
monday: "monday";
|
|
245
|
+
tuesday: "tuesday";
|
|
246
|
+
wednesday: "wednesday";
|
|
247
|
+
thursday: "thursday";
|
|
248
|
+
friday: "friday";
|
|
249
|
+
saturday: "saturday";
|
|
250
|
+
}>>;
|
|
251
|
+
windowStartTime: z.ZodString;
|
|
252
|
+
windowEndTime: z.ZodString;
|
|
253
|
+
active: z.ZodBoolean;
|
|
254
|
+
isAvailable: z.ZodBoolean;
|
|
255
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
256
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
257
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
258
|
+
}, z.core.$strip>;
|
|
259
|
+
availabilityRuleId: z.ZodNumber;
|
|
260
|
+
recurrence: z.ZodEnum<{
|
|
261
|
+
daily: "daily";
|
|
262
|
+
weekly: "weekly";
|
|
263
|
+
}>;
|
|
264
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
265
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
266
|
+
date: z.ZodNull;
|
|
267
|
+
}, z.core.$strip>], "recurrence">;
|
|
268
|
+
export declare const AvailabilityRulesSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
269
|
+
userId: z.ZodNumber;
|
|
270
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
271
|
+
sunday: "sunday";
|
|
272
|
+
monday: "monday";
|
|
273
|
+
tuesday: "tuesday";
|
|
274
|
+
wednesday: "wednesday";
|
|
275
|
+
thursday: "thursday";
|
|
276
|
+
friday: "friday";
|
|
277
|
+
saturday: "saturday";
|
|
278
|
+
}>>;
|
|
279
|
+
windowStartTime: z.ZodString;
|
|
280
|
+
windowEndTime: z.ZodString;
|
|
281
|
+
active: z.ZodBoolean;
|
|
282
|
+
isAvailable: z.ZodBoolean;
|
|
283
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
284
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
285
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
286
|
+
}, z.core.$strip>;
|
|
287
|
+
availabilityRuleId: z.ZodNumber;
|
|
288
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
289
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
290
|
+
dateRangeStart: z.ZodNull;
|
|
291
|
+
dateRangeEnd: z.ZodNull;
|
|
292
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
293
|
+
userId: z.ZodNumber;
|
|
294
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
295
|
+
sunday: "sunday";
|
|
296
|
+
monday: "monday";
|
|
297
|
+
tuesday: "tuesday";
|
|
298
|
+
wednesday: "wednesday";
|
|
299
|
+
thursday: "thursday";
|
|
300
|
+
friday: "friday";
|
|
301
|
+
saturday: "saturday";
|
|
302
|
+
}>>;
|
|
303
|
+
windowStartTime: z.ZodString;
|
|
304
|
+
windowEndTime: z.ZodString;
|
|
305
|
+
active: z.ZodBoolean;
|
|
306
|
+
isAvailable: z.ZodBoolean;
|
|
307
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
308
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
309
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
310
|
+
}, z.core.$strip>;
|
|
311
|
+
availabilityRuleId: z.ZodNumber;
|
|
312
|
+
recurrence: z.ZodEnum<{
|
|
313
|
+
daily: "daily";
|
|
314
|
+
weekly: "weekly";
|
|
315
|
+
}>;
|
|
316
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
317
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
318
|
+
date: z.ZodNull;
|
|
319
|
+
}, z.core.$strip>], "recurrence">>;
|
|
320
|
+
export type AvailabilityRule = z.infer<typeof AvailabilityRuleSchema>;
|
|
321
|
+
export type AvailabilityRules = z.infer<typeof AvailabilityRulesSchema>;
|
|
322
|
+
export declare const UpdateOneOffAvailabilityRuleInputSchema: z.ZodObject<{
|
|
323
|
+
userId: z.ZodOptional<z.ZodNumber>;
|
|
324
|
+
recurrence: z.ZodOptional<z.ZodEnum<{
|
|
325
|
+
one_off: "one_off";
|
|
326
|
+
daily: "daily";
|
|
327
|
+
weekly: "weekly";
|
|
328
|
+
}>>;
|
|
329
|
+
weekdays: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
330
|
+
sunday: "sunday";
|
|
331
|
+
monday: "monday";
|
|
332
|
+
tuesday: "tuesday";
|
|
333
|
+
wednesday: "wednesday";
|
|
334
|
+
thursday: "thursday";
|
|
335
|
+
friday: "friday";
|
|
336
|
+
saturday: "saturday";
|
|
337
|
+
}>>>;
|
|
338
|
+
windowStartTime: z.ZodOptional<z.ZodString>;
|
|
339
|
+
windowEndTime: z.ZodOptional<z.ZodString>;
|
|
340
|
+
availabilityRuleMetadata: z.ZodOptional<z.ZodObject<{
|
|
341
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
342
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
343
|
+
}, z.core.$strip>>;
|
|
344
|
+
isAvailable: z.ZodOptional<z.ZodBoolean>;
|
|
345
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
346
|
+
dateRangeStart: z.ZodDefault<z.ZodNull>;
|
|
347
|
+
dateRangeEnd: z.ZodDefault<z.ZodNull>;
|
|
348
|
+
}, z.core.$strip>;
|
|
349
|
+
export type UpdateOneOffAvailabilityRuleInput = z.infer<typeof UpdateOneOffAvailabilityRuleInputSchema>;
|
|
350
|
+
export declare const UpdateRecurringAvailabilityRuleInputSchema: z.ZodObject<{
|
|
351
|
+
userId: z.ZodOptional<z.ZodNumber>;
|
|
352
|
+
recurrence: z.ZodOptional<z.ZodEnum<{
|
|
353
|
+
one_off: "one_off";
|
|
354
|
+
daily: "daily";
|
|
355
|
+
weekly: "weekly";
|
|
356
|
+
}>>;
|
|
357
|
+
weekdays: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
358
|
+
sunday: "sunday";
|
|
359
|
+
monday: "monday";
|
|
360
|
+
tuesday: "tuesday";
|
|
361
|
+
wednesday: "wednesday";
|
|
362
|
+
thursday: "thursday";
|
|
363
|
+
friday: "friday";
|
|
364
|
+
saturday: "saturday";
|
|
365
|
+
}>>>;
|
|
366
|
+
windowStartTime: z.ZodOptional<z.ZodString>;
|
|
367
|
+
windowEndTime: z.ZodOptional<z.ZodString>;
|
|
368
|
+
availabilityRuleMetadata: z.ZodOptional<z.ZodObject<{
|
|
369
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
370
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
371
|
+
}, z.core.$strip>>;
|
|
372
|
+
isAvailable: z.ZodOptional<z.ZodBoolean>;
|
|
373
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
374
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
375
|
+
}, z.core.$strip>;
|
|
376
|
+
export type UpdateRecurringAvailabilityRuleInput = z.infer<typeof UpdateRecurringAvailabilityRuleInputSchema>;
|
|
377
|
+
export declare const UpdateAvailabilityRuleInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
378
|
+
userId: z.ZodOptional<z.ZodNumber>;
|
|
379
|
+
recurrence: z.ZodOptional<z.ZodEnum<{
|
|
380
|
+
one_off: "one_off";
|
|
381
|
+
daily: "daily";
|
|
382
|
+
weekly: "weekly";
|
|
383
|
+
}>>;
|
|
384
|
+
weekdays: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
385
|
+
sunday: "sunday";
|
|
386
|
+
monday: "monday";
|
|
387
|
+
tuesday: "tuesday";
|
|
388
|
+
wednesday: "wednesday";
|
|
389
|
+
thursday: "thursday";
|
|
390
|
+
friday: "friday";
|
|
391
|
+
saturday: "saturday";
|
|
392
|
+
}>>>;
|
|
393
|
+
windowStartTime: z.ZodOptional<z.ZodString>;
|
|
394
|
+
windowEndTime: z.ZodOptional<z.ZodString>;
|
|
395
|
+
availabilityRuleMetadata: z.ZodOptional<z.ZodObject<{
|
|
396
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
397
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
398
|
+
}, z.core.$strip>>;
|
|
399
|
+
isAvailable: z.ZodOptional<z.ZodBoolean>;
|
|
400
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
401
|
+
dateRangeStart: z.ZodDefault<z.ZodNull>;
|
|
402
|
+
dateRangeEnd: z.ZodDefault<z.ZodNull>;
|
|
403
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
404
|
+
userId: z.ZodOptional<z.ZodNumber>;
|
|
405
|
+
recurrence: z.ZodOptional<z.ZodEnum<{
|
|
406
|
+
one_off: "one_off";
|
|
407
|
+
daily: "daily";
|
|
408
|
+
weekly: "weekly";
|
|
409
|
+
}>>;
|
|
410
|
+
weekdays: z.ZodOptional<z.ZodArray<z.ZodEnum<{
|
|
411
|
+
sunday: "sunday";
|
|
412
|
+
monday: "monday";
|
|
413
|
+
tuesday: "tuesday";
|
|
414
|
+
wednesday: "wednesday";
|
|
415
|
+
thursday: "thursday";
|
|
416
|
+
friday: "friday";
|
|
417
|
+
saturday: "saturday";
|
|
418
|
+
}>>>;
|
|
419
|
+
windowStartTime: z.ZodOptional<z.ZodString>;
|
|
420
|
+
windowEndTime: z.ZodOptional<z.ZodString>;
|
|
421
|
+
availabilityRuleMetadata: z.ZodOptional<z.ZodObject<{
|
|
422
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
423
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
424
|
+
}, z.core.$strip>>;
|
|
425
|
+
isAvailable: z.ZodOptional<z.ZodBoolean>;
|
|
426
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
427
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
428
|
+
}, z.core.$strip>], "recurrence">;
|
|
429
|
+
export type UpdateAvailabilityRuleInput = z.infer<typeof UpdateAvailabilityRuleInputSchema>;
|
|
430
|
+
/**
|
|
431
|
+
* SearchAvailabilityRulesInput
|
|
432
|
+
*/
|
|
433
|
+
export declare const SearchAvailabilityRulesInputSchema: z.ZodObject<{
|
|
434
|
+
userId: z.ZodNumber;
|
|
435
|
+
availabilityRuleId: z.ZodOptional<z.ZodNumber>;
|
|
436
|
+
active: z.ZodOptional<z.ZodBoolean>;
|
|
437
|
+
isAvailable: z.ZodOptional<z.ZodBoolean>;
|
|
438
|
+
dateFrom: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
439
|
+
dateTo: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
440
|
+
pagination: z.ZodDefault<z.ZodObject<{
|
|
441
|
+
limit: z.ZodDefault<z.ZodNumber>;
|
|
442
|
+
offset: z.ZodDefault<z.ZodNumber>;
|
|
443
|
+
}, z.core.$strip>>;
|
|
444
|
+
}, z.core.$strip>;
|
|
445
|
+
export type SearchAvailabilityRulesInput = z.infer<typeof SearchAvailabilityRulesInputSchema>;
|
|
446
|
+
/**
|
|
447
|
+
* SearchAvailabilityRulesOutput
|
|
448
|
+
*/
|
|
449
|
+
export declare const SearchAvailabilityRulesOutputSchema: z.ZodObject<{
|
|
450
|
+
items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
451
|
+
userId: z.ZodNumber;
|
|
452
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
453
|
+
sunday: "sunday";
|
|
454
|
+
monday: "monday";
|
|
455
|
+
tuesday: "tuesday";
|
|
456
|
+
wednesday: "wednesday";
|
|
457
|
+
thursday: "thursday";
|
|
458
|
+
friday: "friday";
|
|
459
|
+
saturday: "saturday";
|
|
460
|
+
}>>;
|
|
461
|
+
windowStartTime: z.ZodString;
|
|
462
|
+
windowEndTime: z.ZodString;
|
|
463
|
+
active: z.ZodBoolean;
|
|
464
|
+
isAvailable: z.ZodBoolean;
|
|
465
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
466
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
467
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
468
|
+
}, z.core.$strip>;
|
|
469
|
+
availabilityRuleId: z.ZodNumber;
|
|
470
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
471
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
472
|
+
dateRangeStart: z.ZodNull;
|
|
473
|
+
dateRangeEnd: z.ZodNull;
|
|
474
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
475
|
+
userId: z.ZodNumber;
|
|
476
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
477
|
+
sunday: "sunday";
|
|
478
|
+
monday: "monday";
|
|
479
|
+
tuesday: "tuesday";
|
|
480
|
+
wednesday: "wednesday";
|
|
481
|
+
thursday: "thursday";
|
|
482
|
+
friday: "friday";
|
|
483
|
+
saturday: "saturday";
|
|
484
|
+
}>>;
|
|
485
|
+
windowStartTime: z.ZodString;
|
|
486
|
+
windowEndTime: z.ZodString;
|
|
487
|
+
active: z.ZodBoolean;
|
|
488
|
+
isAvailable: z.ZodBoolean;
|
|
489
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
490
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
491
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
492
|
+
}, z.core.$strip>;
|
|
493
|
+
availabilityRuleId: z.ZodNumber;
|
|
494
|
+
recurrence: z.ZodEnum<{
|
|
495
|
+
daily: "daily";
|
|
496
|
+
weekly: "weekly";
|
|
497
|
+
}>;
|
|
498
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
499
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
500
|
+
date: z.ZodNull;
|
|
501
|
+
}, z.core.$strip>], "recurrence">>;
|
|
502
|
+
pagination: z.ZodObject<{
|
|
503
|
+
total: z.ZodCoercedNumber<unknown>;
|
|
504
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
|
|
505
|
+
offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
|
|
506
|
+
hasMore: z.ZodBoolean;
|
|
507
|
+
}, z.core.$strip>;
|
|
508
|
+
}, z.core.$strip>;
|
|
509
|
+
export type SearchAvailabilityRulesOutput = z.infer<typeof SearchAvailabilityRulesOutputSchema>;
|
|
510
|
+
/**
|
|
511
|
+
* Paginated availability rule schema
|
|
512
|
+
*/
|
|
513
|
+
export declare const PaginatedAvailabilityRulesSchema: z.ZodObject<{
|
|
514
|
+
items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
515
|
+
userId: z.ZodNumber;
|
|
516
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
517
|
+
sunday: "sunday";
|
|
518
|
+
monday: "monday";
|
|
519
|
+
tuesday: "tuesday";
|
|
520
|
+
wednesday: "wednesday";
|
|
521
|
+
thursday: "thursday";
|
|
522
|
+
friday: "friday";
|
|
523
|
+
saturday: "saturday";
|
|
524
|
+
}>>;
|
|
525
|
+
windowStartTime: z.ZodString;
|
|
526
|
+
windowEndTime: z.ZodString;
|
|
527
|
+
active: z.ZodBoolean;
|
|
528
|
+
isAvailable: z.ZodBoolean;
|
|
529
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
530
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
531
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
532
|
+
}, z.core.$strip>;
|
|
533
|
+
availabilityRuleId: z.ZodNumber;
|
|
534
|
+
recurrence: z.ZodLiteral<"one_off">;
|
|
535
|
+
date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
536
|
+
dateRangeStart: z.ZodNull;
|
|
537
|
+
dateRangeEnd: z.ZodNull;
|
|
538
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
539
|
+
userId: z.ZodNumber;
|
|
540
|
+
weekdays: z.ZodArray<z.ZodEnum<{
|
|
541
|
+
sunday: "sunday";
|
|
542
|
+
monday: "monday";
|
|
543
|
+
tuesday: "tuesday";
|
|
544
|
+
wednesday: "wednesday";
|
|
545
|
+
thursday: "thursday";
|
|
546
|
+
friday: "friday";
|
|
547
|
+
saturday: "saturday";
|
|
548
|
+
}>>;
|
|
549
|
+
windowStartTime: z.ZodString;
|
|
550
|
+
windowEndTime: z.ZodString;
|
|
551
|
+
active: z.ZodBoolean;
|
|
552
|
+
isAvailable: z.ZodBoolean;
|
|
553
|
+
availabilityRuleMetadata: z.ZodObject<{
|
|
554
|
+
bookingLocationIds: z.ZodArray<z.ZodNumber>;
|
|
555
|
+
serviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
|
|
556
|
+
}, z.core.$strip>;
|
|
557
|
+
availabilityRuleId: z.ZodNumber;
|
|
558
|
+
recurrence: z.ZodEnum<{
|
|
559
|
+
daily: "daily";
|
|
560
|
+
weekly: "weekly";
|
|
561
|
+
}>;
|
|
562
|
+
dateRangeStart: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
|
|
563
|
+
dateRangeEnd: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
|
|
564
|
+
date: z.ZodNull;
|
|
565
|
+
}, z.core.$strip>], "recurrence">>;
|
|
566
|
+
pagination: z.ZodObject<{
|
|
567
|
+
total: z.ZodCoercedNumber<unknown>;
|
|
568
|
+
limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
|
|
569
|
+
offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
|
|
570
|
+
hasMore: z.ZodBoolean;
|
|
571
|
+
}, z.core.$strip>;
|
|
572
|
+
}, z.core.$strip>;
|
|
573
|
+
export type PaginatedAvailabilityRules = z.infer<typeof PaginatedAvailabilityRulesSchema>;
|
|
574
|
+
export {};
|