balendar 0.0.7 → 0.0.9

package/dist/src/modules/calendar-mappings/calendar-mappings.domain.d.ts

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+/**
+ * Calendar Mapping Status
+ */
+export declare const CalendarMappingStatuses: readonly ["active", "expired", "revoked", "error"];
+export declare const CalendarMappingStatusSchema: z.ZodEnum<{
+    error: "error";
+    active: "active";
+    expired: "expired";
+    revoked: "revoked";
+}>;
+export type CalendarMappingStatus = z.infer<typeof CalendarMappingStatusSchema>;
+/**
+ * Create Calendar Mapping Input
+ */
+export declare const CreateCalendarMappingInputSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    externalProvider: z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>;
+    connectionId: z.ZodString;
+    accessToken: z.ZodString;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+}, z.core.$strip>;
+export type CreateCalendarMappingInput = z.infer<typeof CreateCalendarMappingInputSchema>;
+/**
+ * Calendar Mapping
+ */
+export declare const CalendarMappingSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    externalProvider: z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>;
+    connectionId: z.ZodString;
+    accessToken: z.ZodString;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    calendarMappingId: z.ZodNumber;
+    status: z.ZodEnum<{
+        error: "error";
+        active: "active";
+        expired: "expired";
+        revoked: "revoked";
+    }>;
+    syncToken: z.ZodNullable<z.ZodString>;
+    webhookId: z.ZodNullable<z.ZodString>;
+    webhookResourceId: z.ZodNullable<z.ZodString>;
+    webhookExpiresAt: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+}, z.core.$strip>;
+export type CalendarMapping = z.infer<typeof CalendarMappingSchema>;
+export declare const CalendarMappingsSchema: z.ZodArray<z.ZodObject<{
+    userId: z.ZodNumber;
+    externalProvider: z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>;
+    connectionId: z.ZodString;
+    accessToken: z.ZodString;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    calendarMappingId: z.ZodNumber;
+    status: z.ZodEnum<{
+        error: "error";
+        active: "active";
+        expired: "expired";
+        revoked: "revoked";
+    }>;
+    syncToken: z.ZodNullable<z.ZodString>;
+    webhookId: z.ZodNullable<z.ZodString>;
+    webhookResourceId: z.ZodNullable<z.ZodString>;
+    webhookExpiresAt: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+}, z.core.$strip>>;
+export type CalendarMappings = z.infer<typeof CalendarMappingsSchema>;
+/**
+ * Update Calendar Mapping Input
+ */
+export declare const UpdateCalendarMappingInputSchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodNumber>;
+    expiresAt: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    syncToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    webhookId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    webhookResourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    webhookExpiresAt: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>>;
+}, z.core.$strip>;
+export type UpdateCalendarMappingInput = z.infer<typeof UpdateCalendarMappingInputSchema>;
+/**
+ * PaginatedCalendarMappings
+ */
+export declare const PaginatedCalendarMappingsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        externalProvider: z.ZodEnum<{
+            apple: "apple";
+            google: "google";
+            microsoft: "microsoft";
+        }>;
+        connectionId: z.ZodString;
+        accessToken: z.ZodString;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        calendarMappingId: z.ZodNumber;
+        status: z.ZodEnum<{
+            error: "error";
+            active: "active";
+            expired: "expired";
+            revoked: "revoked";
+        }>;
+        syncToken: z.ZodNullable<z.ZodString>;
+        webhookId: z.ZodNullable<z.ZodString>;
+        webhookResourceId: z.ZodNullable<z.ZodString>;
+        webhookExpiresAt: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        total: z.ZodCoercedNumber<unknown>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PaginatedCalendarMappings = z.infer<typeof PaginatedCalendarMappingsSchema>;
+/**
+ * SearchCalendarMappingsInput
+ */
+export declare const SearchCalendarMappingsInputSchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodNumber>;
+    connectionId: z.ZodOptional<z.ZodString>;
+    webhookResourceId: z.ZodOptional<z.ZodString>;
+    pagination: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SearchCalendarMappingsInput = z.infer<typeof SearchCalendarMappingsInputSchema>;
+/**
+ * SearchCalendarMappingsOutput
+ */
+export declare const SearchCalendarMappingsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        externalProvider: z.ZodEnum<{
+            apple: "apple";
+            google: "google";
+            microsoft: "microsoft";
+        }>;
+        connectionId: z.ZodString;
+        accessToken: z.ZodString;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        calendarMappingId: z.ZodNumber;
+        status: z.ZodEnum<{
+            error: "error";
+            active: "active";
+            expired: "expired";
+            revoked: "revoked";
+        }>;
+        syncToken: z.ZodNullable<z.ZodString>;
+        webhookId: z.ZodNullable<z.ZodString>;
+        webhookResourceId: z.ZodNullable<z.ZodString>;
+        webhookExpiresAt: z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        total: z.ZodCoercedNumber<unknown>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SearchCalendarMappingsOutput = z.infer<typeof SearchCalendarMappingsOutputSchema>;

package/dist/src/modules/event-mappings/event-mappings.domain.d.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+/**
+ * Create event mapping input schema
+ */
+export declare const CreateEventMappingInputSchema: z.ZodObject<{
+    eventId: z.ZodNumber;
+    calendarConnectionId: z.ZodString;
+    externalId: z.ZodNullable<z.ZodString>;
+    externalProvider: z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>;
+}, z.core.$strip>;
+export type CreateEventMappingInput = z.infer<typeof CreateEventMappingInputSchema>;
+/**
+ * Event mapping schema
+ */
+export declare const EventMappingSchema: z.ZodObject<{
+    eventId: z.ZodNumber;
+    calendarConnectionId: z.ZodString;
+    externalId: z.ZodNullable<z.ZodString>;
+    externalProvider: z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>;
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    eventMappingId: z.ZodNumber;
+}, z.core.$strip>;
+export declare const EventMappingsSchema: z.ZodArray<z.ZodObject<{
+    eventId: z.ZodNumber;
+    calendarConnectionId: z.ZodString;
+    externalId: z.ZodNullable<z.ZodString>;
+    externalProvider: z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>;
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    eventMappingId: z.ZodNumber;
+}, z.core.$strip>>;
+export type EventMapping = z.infer<typeof EventMappingSchema>;
+export type EventMappings = z.infer<typeof EventMappingsSchema>;
+/**
+ * Update event mapping input schema
+ */
+export declare const UpdateEventMappingInputSchema: z.ZodObject<{
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type UpdateEventMappingInput = z.infer<typeof UpdateEventMappingInputSchema>;
+/**
+ * Paginated event mappings schema
+ */
+export declare const PaginatedEventMappingsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodNumber;
+        calendarConnectionId: z.ZodString;
+        externalId: z.ZodNullable<z.ZodString>;
+        externalProvider: z.ZodEnum<{
+            apple: "apple";
+            google: "google";
+            microsoft: "microsoft";
+        }>;
+        createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        eventMappingId: z.ZodNumber;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        total: z.ZodCoercedNumber<unknown>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PaginatedEventMappings = z.infer<typeof PaginatedEventMappingsSchema>;
+/**
+ * SearchEventMappingsInput
+ */
+export declare const SearchEventMappingsInputSchema: z.ZodObject<{
+    eventId: z.ZodOptional<z.ZodNumber>;
+    eventMappingId: z.ZodOptional<z.ZodNumber>;
+    calendarConnectionId: z.ZodOptional<z.ZodString>;
+    externalId: z.ZodOptional<z.ZodString>;
+    externalProvider: z.ZodOptional<z.ZodEnum<{
+        apple: "apple";
+        google: "google";
+        microsoft: "microsoft";
+    }>>;
+    pagination: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SearchEventMappingsInput = z.infer<typeof SearchEventMappingsInputSchema>;
+/**
+ * SearchEventMappingsOutput
+ */
+export declare const SearchEventMappingsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        eventId: z.ZodNumber;
+        calendarConnectionId: z.ZodString;
+        externalId: z.ZodNullable<z.ZodString>;
+        externalProvider: z.ZodEnum<{
+            apple: "apple";
+            google: "google";
+            microsoft: "microsoft";
+        }>;
+        createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        eventMappingId: z.ZodNumber;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        total: z.ZodCoercedNumber<unknown>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SearchEventMappingsOutput = z.infer<typeof SearchEventMappingsOutputSchema>;

package/dist/src/modules/events/events.domain.d.ts

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+export declare const Title: z.ZodString;
+export declare const Description: z.ZodString;
+export declare const Location: z.ZodString;
+/**
+ * EventStatus
+ */
+export declare const EventStatuses: readonly ["confirmed", "cancelled", "tentative"];
+export declare const EventStatusesSchema: z.ZodEnum<{
+    confirmed: "confirmed";
+    cancelled: "cancelled";
+    tentative: "tentative";
+}>;
+export type EventStatus = z.infer<typeof EventStatusesSchema>;
+/**
+ * EventBusyStatus
+ */
+export declare const EventBusyStatuses: readonly ["busy", "free"];
+export declare const EventBusyStatusesSchema: z.ZodEnum<{
+    busy: "busy";
+    free: "free";
+}>;
+export type EventBusyStatus = z.infer<typeof EventBusyStatusesSchema>;
+export declare const CreateEventInputSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    bookingId: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+    title: z.ZodString;
+    description: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    location: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    startTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    endTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    status: z.ZodEnum<{
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+        tentative: "tentative";
+    }>;
+    busyStatus: z.ZodDefault<z.ZodEnum<{
+        busy: "busy";
+        free: "free";
+    }>>;
+}, z.core.$strip>;
+export type CreateEventInput = z.infer<typeof CreateEventInputSchema>;
+/**
+ * Event
+ */
+export declare const EventSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    title: z.ZodString;
+    startTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    endTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    status: z.ZodEnum<{
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+        tentative: "tentative";
+    }>;
+    busyStatus: z.ZodDefault<z.ZodEnum<{
+        busy: "busy";
+        free: "free";
+    }>>;
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    eventId: z.ZodNumber;
+    bookingId: z.ZodNullable<z.ZodNumber>;
+    description: z.ZodNullable<z.ZodString>;
+    location: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const EventsSchema: z.ZodArray<z.ZodObject<{
+    userId: z.ZodNumber;
+    title: z.ZodString;
+    startTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    endTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    status: z.ZodEnum<{
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+        tentative: "tentative";
+    }>;
+    busyStatus: z.ZodDefault<z.ZodEnum<{
+        busy: "busy";
+        free: "free";
+    }>>;
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    eventId: z.ZodNumber;
+    bookingId: z.ZodNullable<z.ZodNumber>;
+    description: z.ZodNullable<z.ZodString>;
+    location: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>>;
+export type Event = z.infer<typeof EventSchema>;
+export type Events = z.infer<typeof EventsSchema>;
+/**
+ * UpdateEventInput
+ */
+export declare const UpdateEventInputSchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<{
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+        tentative: "tentative";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>>;
+    startTime: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+    endTime: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>>;
+    location: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>>;
+    busyStatus: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        busy: "busy";
+        free: "free";
+    }>>>;
+}, z.core.$strip>;
+export type UpdateEventInput = z.infer<typeof UpdateEventInputSchema>;
+/**
+ * SearchEventsInput
+ */
+export declare const SearchEventsInputSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    startDate: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    endDate: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        confirmed: "confirmed";
+        cancelled: "cancelled";
+        tentative: "tentative";
+    }>>;
+    busyStatus: z.ZodOptional<z.ZodEnum<{
+        busy: "busy";
+        free: "free";
+    }>>;
+    pagination: z.ZodDefault<z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SearchEventsInput = z.infer<typeof SearchEventsInputSchema>;
+/**
+ * SearchEventsOutput
+ */
+export declare const SearchEventsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        title: z.ZodString;
+        startTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        endTime: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        status: z.ZodEnum<{
+            confirmed: "confirmed";
+            cancelled: "cancelled";
+            tentative: "tentative";
+        }>;
+        busyStatus: z.ZodDefault<z.ZodEnum<{
+            busy: "busy";
+            free: "free";
+        }>>;
+        createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        eventId: z.ZodNumber;
+        bookingId: z.ZodNullable<z.ZodNumber>;
+        description: z.ZodNullable<z.ZodString>;
+        location: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        total: z.ZodCoercedNumber<unknown>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SearchEventsOutput = z.infer<typeof SearchEventsOutputSchema>;

package/dist/src/orchestrators/availability/availability.domain.d.ts

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+declare const TimeSlotsSchema: z.ZodArray<z.ZodObject<{
+    date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    time: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;
+export type TimeSlots = z.infer<typeof TimeSlotsSchema>;
+/**
+ * BookingLocationFilter
+ */
+declare const BookingLocationFilterSchema: z.ZodObject<{
+    bookingLocationId: z.ZodNumber;
+    bufferMinutes: z.ZodNumber;
+    leadMinutes: z.ZodNumber;
+}, z.core.$strip>;
+export type BookingLocationFilter = z.infer<typeof BookingLocationFilterSchema>;
+declare const BookingLocationsAvailabilitySchema: z.ZodArray<z.ZodObject<{
+    bookingLocationId: z.ZodNumber;
+    timeSlotCount: z.ZodNumber;
+    timeSlots: z.ZodArray<z.ZodObject<{
+        date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        time: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export type BookingLocationsAvailability = z.infer<typeof BookingLocationsAvailabilitySchema>;
+/**
+ * BaseAvailabilitySearchFilters
+ * Shared filters applied to all users in multi-user searches
+ */
+export declare const BaseAvailabilitySearchFiltersSchema: z.ZodObject<{
+    dateFrom: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    dateTo: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    timeFrom: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    timeTo: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type BaseAvailabilitySearchFilters = z.infer<typeof BaseAvailabilitySearchFiltersSchema>;
+/**
+ * PerUserAvailabilitySearchFilters
+ * Per-user filters that extend the base filters
+ */
+declare const PerUserAvailabilitySearchFiltersSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    bookingLocations: z.ZodArray<z.ZodObject<{
+        bookingLocationId: z.ZodNumber;
+        bufferMinutes: z.ZodNumber;
+        leadMinutes: z.ZodNumber;
+    }, z.core.$strip>>;
+    bookingDurationMinutes: z.ZodDefault<z.ZodNumber>;
+    slotGapMinutes: z.ZodDefault<z.ZodNumber>;
+    timeZone: z.ZodString;
+}, z.core.$strip>;
+export type PerUserAvailabilitySearchFilters = z.infer<typeof PerUserAvailabilitySearchFiltersSchema>;
+export declare const UserAvailabilitySearchInputSchema: z.ZodObject<{
+    filters: z.ZodObject<{
+        dateFrom: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        dateTo: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        timeFrom: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        timeTo: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        userId: z.ZodNumber;
+        bookingLocations: z.ZodArray<z.ZodObject<{
+            bookingLocationId: z.ZodNumber;
+            bufferMinutes: z.ZodNumber;
+            leadMinutes: z.ZodNumber;
+        }, z.core.$strip>>;
+        bookingDurationMinutes: z.ZodDefault<z.ZodNumber>;
+        slotGapMinutes: z.ZodDefault<z.ZodNumber>;
+        timeZone: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UserAvailabilitySearchInput = z.infer<typeof UserAvailabilitySearchInputSchema>;
+export declare const UserAvailabilitySchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    timeZone: z.ZodString;
+    bookingLocationAvailability: z.ZodArray<z.ZodObject<{
+        bookingLocationId: z.ZodNumber;
+        timeSlotCount: z.ZodNumber;
+        timeSlots: z.ZodArray<z.ZodObject<{
+            date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+            time: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UserAvailability = z.infer<typeof UserAvailabilitySchema>;
+/**
+ * MultiUserAvailabilitySearchInput
+ * Search for availability across multiple users
+ */
+export declare const MultiUserAvailabilitySearchInputSchema: z.ZodObject<{
+    baseFilters: z.ZodObject<{
+        dateFrom: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        dateTo: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        timeFrom: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        timeTo: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>;
+    userFilters: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNumber;
+        bookingLocations: z.ZodArray<z.ZodObject<{
+            bookingLocationId: z.ZodNumber;
+            bufferMinutes: z.ZodNumber;
+            leadMinutes: z.ZodNumber;
+        }, z.core.$strip>>;
+        bookingDurationMinutes: z.ZodDefault<z.ZodNumber>;
+        slotGapMinutes: z.ZodDefault<z.ZodNumber>;
+        timeZone: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MultiUserAvailabilitySearchInput = z.infer<typeof MultiUserAvailabilitySearchInputSchema>;
+/**
+ * MultiUserAvailability
+ * Output for multi-user availability search, sorted by availability
+ */
+export declare const MultiUserAvailabilitySchema: z.ZodArray<z.ZodObject<{
+    userId: z.ZodNumber;
+    timeZone: z.ZodString;
+    bookingLocationAvailability: z.ZodArray<z.ZodObject<{
+        bookingLocationId: z.ZodNumber;
+        timeSlotCount: z.ZodNumber;
+        timeSlots: z.ZodArray<z.ZodObject<{
+            date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+            time: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export type MultiUserAvailability = z.infer<typeof MultiUserAvailabilitySchema>;
+/**
+ * UserDateCheckOutput
+ * The output schema for a high level availability check for a user.
+ * This is used for quickly checking the availability of a user for a given date/date range.
+ *
+ * Example: We have a calendar picker UI where the user can select a date to check the availability for.
+ * We want to indicate whether a specific date has any availability or not.
+ * We don't need to know the exact availability times, just whether it's available or not.
+ */
+export declare const UserDateCheckOutputSchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    timeZone: z.ZodString;
+    anyAvailability: z.ZodBoolean;
+    availability: z.ZodObject<{
+        date: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+        isAvailable: z.ZodBoolean;
+    }, z.core.$strip>;
+    bookingLocationId: z.ZodNumber;
+}, z.core.$strip>;
+export {};

package/dist/src/shared/schemas/audit.models.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const AuditColumnsSchema: z.ZodObject<{
+    createdAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+    updatedAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+}, z.core.$strip>;
+export type AuditColumns = z.infer<typeof AuditColumnsSchema>;

package/dist/src/shared/schemas/date-time.models.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/**
+ * DateTime in ISO 8601 format
+ * Used for all rule types to specify date and time
+ * Examples: "2025-01-01T09:00:00Z", "2025-01-01T17:30:00Z"
+ */
+export declare const DateTimeSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+export type DateTime = z.infer<typeof DateTimeSchema>;
+/**
+ * Date only in YYYY-MM-DD format
+ * Used for all rule types to specify date
+ * Examples: "2025-01-01", "2025-12-31"
+ */
+export declare const DateOnlySchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>;
+export type DateOnly = z.infer<typeof DateOnlySchema>;
+/**
+ * Time of day in 24-hour format (HH:mm)
+ * Used for all rule types to specify daily time windows
+ * Examples: "09:00", "17:30", "00:00"
+ */
+export declare const Time24HourSchema: z.ZodString;
+export type Time24Hour = z.infer<typeof Time24HourSchema>;
+/**
+ * TimeZone
+ * TODO: Implement time zone validation. Static list?
+ */
+export declare const TimeZoneSchema: z.ZodString;
+export type TimeZone = z.infer<typeof TimeZoneSchema>;

package/dist/src/shared/schemas/external-providers.models.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/**
+ * External providers
+ */
+export declare const APPLE = "apple";
+export declare const GOOGLE = "google";
+export declare const MICROSOFT = "microsoft";
+export declare const ExternalProviders: readonly ["apple", "google", "microsoft"];
+export declare const ExternalProvidersSchema: z.ZodEnum<{
+    apple: "apple";
+    google: "google";
+    microsoft: "microsoft";
+}>;
+export type ExternalProvider = z.infer<typeof ExternalProvidersSchema>;

package/dist/src/shared/schemas/id.models.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const IDSchema: z.ZodNumber;
+export type ID = z.infer<typeof IDSchema>;
+export declare const IDsSchema: z.ZodArray<z.ZodNumber>;
+export type IDs = z.infer<typeof IDsSchema>;
+export declare const IDParamSchema: z.ZodCoercedNumber<unknown>;
+export type IDParam = z.infer<typeof IDParamSchema>;
+export declare const ExternalIDSchema: z.ZodString;
+export type ExternalID = z.infer<typeof ExternalIDSchema>;