@calcom/atoms 1.0.101 → 1.0.102-framer

package/dist/packages/features/bookings/lib/handleNewBooking/ensureAvailableUsers.d.ts

@@ -1,13 +1,620 @@
 import type { Logger } from "tslog";
-import type { getEventTypeResponse } from "./getEventTypesFromDB";
 import type { BookingType } from "./originalRescheduledBookingUtils";
 import type { IsFixedAwareUser } from "./types";
-export declare function ensureAvailableUsers(eventType: Omit<getEventTypeResponse, "users"> & {
+export declare const ensureAvailableUsers: (eventType: Omit<{
+    hosts: {
+        user: Omit<{
+            availability: {
+                date: Date | null;
+                days: number[];
+                startTime: Date;
+                endTime: Date;
+                id: number;
+                userId: number | null;
+                eventTypeId: number | null;
+                scheduleId: number | null;
+            }[];
+            startTime: number;
+            endTime: number;
+            id: number;
+            locale: string | null;
+            username: string | null;
+            email: string;
+            name: string | null;
+            theme: string | null;
+            locked: boolean;
+            schedules: {
+                availability: {
+                    date: Date | null;
+                    days: number[];
+                    startTime: Date;
+                    endTime: Date;
+                }[];
+                id: number;
+                timeZone: string | null;
+            }[];
+            metadata: import('../../../../prisma-client').Prisma.JsonValue;
+            destinationCalendar: {
+                id: number;
+                userId: number | null;
+                eventTypeId: number | null;
+                integration: string;
+                externalId: string;
+                primaryEmail: string | null;
+                credentialId: number | null;
+                delegationCredentialId: string | null;
+                domainWideDelegationCredentialId: string | null;
+            } | null;
+            timeZone: string;
+            selectedCalendars: {
+                id: string;
+                userId: number;
+                eventTypeId: number | null;
+                error: string | null;
+                integration: string;
+                externalId: string;
+                credentialId: number | null;
+                delegationCredentialId: string | null;
+                domainWideDelegationCredentialId: string | null;
+                googleChannelId: string | null;
+                googleChannelKind: string | null;
+                googleChannelResourceId: string | null;
+                googleChannelResourceUri: string | null;
+                googleChannelExpiration: string | null;
+            }[];
+            bufferTime: number;
+            hideBranding: boolean;
+            defaultScheduleId: number | null;
+            timeFormat: number | null;
+            brandColor: string | null;
+            darkBrandColor: string | null;
+            allowDynamicBooking: boolean | null;
+            travelSchedules: {
+                id: number;
+                userId: number;
+                timeZone: string;
+                endDate: Date | null;
+                startDate: Date;
+                prevTimeZone: string | null;
+            }[];
+            credentials: {
+                id: number;
+                userId: number | null;
+                type: string;
+                user: {
+                    email: string;
+                } | null;
+                teamId: number | null;
+                delegationCredentialId: string | null;
+                key: import('../../../../prisma-client').Prisma.JsonValue;
+                appId: string | null;
+                invalid: boolean | null;
+            }[];
+        }, "selectedCalendars"> & {
+            allSelectedCalendars: {
+                id: string;
+                userId: number;
+                eventTypeId: number | null;
+                error: string | null;
+                integration: string;
+                externalId: string;
+                credentialId: number | null;
+                delegationCredentialId: string | null;
+                domainWideDelegationCredentialId: string | null;
+                googleChannelId: string | null;
+                googleChannelKind: string | null;
+                googleChannelResourceId: string | null;
+                googleChannelResourceUri: string | null;
+                googleChannelExpiration: string | null;
+            }[];
+            userLevelSelectedCalendars: {
+                id: string;
+                userId: number;
+                eventTypeId: number | null;
+                error: string | null;
+                integration: string;
+                externalId: string;
+                credentialId: number | null;
+                delegationCredentialId: string | null;
+                domainWideDelegationCredentialId: string | null;
+                googleChannelId: string | null;
+                googleChannelKind: string | null;
+                googleChannelResourceId: string | null;
+                googleChannelResourceUri: string | null;
+                googleChannelExpiration: string | null;
+            }[];
+        };
+        weight: number | null;
+        schedule: {
+            availability: {
+                date: Date | null;
+                days: number[];
+                startTime: Date;
+                endTime: Date;
+            }[];
+            id: number;
+            timeZone: string | null;
+        } | null;
+        createdAt: Date;
+        priority: number | null;
+        isFixed: boolean;
+    }[];
+    users: (Omit<{
+        availability: {
+            date: Date | null;
+            days: number[];
+            startTime: Date;
+            endTime: Date;
+            id: number;
+            userId: number | null;
+            eventTypeId: number | null;
+            scheduleId: number | null;
+        }[];
+        startTime: number;
+        endTime: number;
+        id: number;
+        locale: string | null;
+        username: string | null;
+        email: string;
+        name: string | null;
+        theme: string | null;
+        locked: boolean;
+        schedules: {
+            availability: {
+                date: Date | null;
+                days: number[];
+                startTime: Date;
+                endTime: Date;
+            }[];
+            id: number;
+            timeZone: string | null;
+        }[];
+        metadata: import('../../../../prisma-client').Prisma.JsonValue;
+        destinationCalendar: {
+            id: number;
+            userId: number | null;
+            eventTypeId: number | null;
+            integration: string;
+            externalId: string;
+            primaryEmail: string | null;
+            credentialId: number | null;
+            delegationCredentialId: string | null;
+            domainWideDelegationCredentialId: string | null;
+        } | null;
+        timeZone: string;
+        selectedCalendars: {
+            id: string;
+            userId: number;
+            eventTypeId: number | null;
+            error: string | null;
+            integration: string;
+            externalId: string;
+            credentialId: number | null;
+            delegationCredentialId: string | null;
+            domainWideDelegationCredentialId: string | null;
+            googleChannelId: string | null;
+            googleChannelKind: string | null;
+            googleChannelResourceId: string | null;
+            googleChannelResourceUri: string | null;
+            googleChannelExpiration: string | null;
+        }[];
+        bufferTime: number;
+        hideBranding: boolean;
+        defaultScheduleId: number | null;
+        timeFormat: number | null;
+        brandColor: string | null;
+        darkBrandColor: string | null;
+        allowDynamicBooking: boolean | null;
+        travelSchedules: {
+            id: number;
+            userId: number;
+            timeZone: string;
+            endDate: Date | null;
+            startDate: Date;
+            prevTimeZone: string | null;
+        }[];
+        credentials: {
+            id: number;
+            userId: number | null;
+            type: string;
+            user: {
+                email: string;
+            } | null;
+            teamId: number | null;
+            delegationCredentialId: string | null;
+            key: import('../../../../prisma-client').Prisma.JsonValue;
+            appId: string | null;
+            invalid: boolean | null;
+        }[];
+    }, "selectedCalendars"> & {
+        allSelectedCalendars: {
+            id: string;
+            userId: number;
+            eventTypeId: number | null;
+            error: string | null;
+            integration: string;
+            externalId: string;
+            credentialId: number | null;
+            delegationCredentialId: string | null;
+            domainWideDelegationCredentialId: string | null;
+            googleChannelId: string | null;
+            googleChannelKind: string | null;
+            googleChannelResourceId: string | null;
+            googleChannelResourceUri: string | null;
+            googleChannelExpiration: string | null;
+        }[];
+        userLevelSelectedCalendars: {
+            id: string;
+            userId: number;
+            eventTypeId: number | null;
+            error: string | null;
+            integration: string;
+            externalId: string;
+            credentialId: number | null;
+            delegationCredentialId: string | null;
+            domainWideDelegationCredentialId: string | null;
+            googleChannelId: string | null;
+            googleChannelKind: string | null;
+            googleChannelResourceId: string | null;
+            googleChannelResourceUri: string | null;
+            googleChannelExpiration: string | null;
+        }[];
+    })[];
+    metadata: {
+        bookerLayouts?: {
+            defaultLayout: import('../../../../prisma/zod-utils').BookerLayouts;
+            enabledLayouts: import('../../../../prisma/zod-utils').BookerLayouts[];
+        } | null | undefined;
+        requiresConfirmationThreshold?: {
+            time: number;
+            unit: "milliseconds" | "seconds" | "minutes" | "hours" | "days" | "months" | "years" | "dates";
+        } | undefined;
+        config?: {
+            useHostSchedulesForTeamEvent?: boolean | undefined;
+        } | undefined;
+        smartContractAddress?: string | undefined;
+        blockchainId?: number | undefined;
+        multipleDuration?: number[] | undefined;
+        giphyThankYouPage?: string | undefined;
+        additionalNotesRequired?: boolean | undefined;
+        disableSuccessPage?: boolean | undefined;
+        disableStandardEmails?: {
+            all?: {
+                host?: boolean | undefined;
+                attendee?: boolean | undefined;
+            } | undefined;
+            confirmation?: {
+                host?: boolean | undefined;
+                attendee?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        managedEventConfig?: {
+            unlockedFields?: {
+                length?: true | undefined;
+                availability?: true | undefined;
+                userId?: true | undefined;
+                scheduleId?: true | undefined;
+                price?: true | undefined;
+                bookings?: true | undefined;
+                webhooks?: true | undefined;
+                profile?: true | undefined;
+                owner?: true | undefined;
+                title?: true | undefined;
+                description?: true | undefined;
+                hidden?: true | undefined;
+                team?: true | undefined;
+                workflows?: true | undefined;
+                users?: true | undefined;
+                hosts?: true | undefined;
+                currency?: true | undefined;
+                slug?: true | undefined;
+                schedule?: true | undefined;
+                children?: true | undefined;
+                metadata?: true | undefined;
+                destinationCalendar?: true | undefined;
+                hashedLink?: true | undefined;
+                secondaryEmail?: true | undefined;
+                customInputs?: true | undefined;
+                position?: true | undefined;
+                locations?: true | undefined;
+                offsetStart?: true | undefined;
+                profileId?: true | undefined;
+                teamId?: true | undefined;
+                useEventLevelSelectedCalendars?: true | undefined;
+                eventName?: true | undefined;
+                parentId?: true | undefined;
+                bookingFields?: true | undefined;
+                timeZone?: true | undefined;
+                periodType?: true | undefined;
+                periodStartDate?: true | undefined;
+                periodEndDate?: true | undefined;
+                periodDays?: true | undefined;
+                periodCountCalendarDays?: true | undefined;
+                lockTimeZoneToggleOnBookingPage?: true | undefined;
+                requiresConfirmation?: true | undefined;
+                requiresConfirmationWillBlockSlot?: true | undefined;
+                requiresConfirmationForFreeEmail?: true | undefined;
+                requiresBookerEmailVerification?: true | undefined;
+                canSendCalVideoTranscriptionEmails?: true | undefined;
+                autoTranslateDescriptionEnabled?: true | undefined;
+                recurringEvent?: true | undefined;
+                disableGuests?: true | undefined;
+                hideCalendarNotes?: true | undefined;
+                hideCalendarEventDetails?: true | undefined;
+                minimumBookingNotice?: true | undefined;
+                beforeEventBuffer?: true | undefined;
+                afterEventBuffer?: true | undefined;
+                seatsPerTimeSlot?: true | undefined;
+                onlyShowFirstAvailableSlot?: true | undefined;
+                disableCancelling?: true | undefined;
+                disableRescheduling?: true | undefined;
+                seatsShowAttendees?: true | undefined;
+                seatsShowAvailabilityCount?: true | undefined;
+                schedulingType?: true | undefined;
+                slotInterval?: true | undefined;
+                successRedirectUrl?: true | undefined;
+                forwardParamsSuccessRedirect?: true | undefined;
+                bookingLimits?: true | undefined;
+                durationLimits?: true | undefined;
+                isInstantEvent?: true | undefined;
+                instantMeetingExpiryTimeOffsetInSeconds?: true | undefined;
+                instantMeetingScheduleId?: true | undefined;
+                instantMeetingParameters?: true | undefined;
+                assignAllTeamMembers?: true | undefined;
+                assignRRMembersUsingSegment?: true | undefined;
+                rrSegmentQueryValue?: true | undefined;
+                useEventTypeDestinationCalendarEmail?: true | undefined;
+                isRRWeightsEnabled?: true | undefined;
+                maxLeadThreshold?: true | undefined;
+                includeNoShowInRRCalculation?: true | undefined;
+                allowReschedulingPastBookings?: true | undefined;
+                hideOrganizerEmail?: true | undefined;
+                customReplyToEmail?: true | undefined;
+                eventTypeColor?: true | undefined;
+                rescheduleWithSameRoundRobinHost?: true | undefined;
+                secondaryEmailId?: true | undefined;
+                parent?: true | undefined;
+                instantMeetingSchedule?: true | undefined;
+                aiPhoneCallConfig?: true | undefined;
+                fieldTranslations?: true | undefined;
+                selectedCalendars?: true | undefined;
+                _count?: true | undefined;
+            } | undefined;
+        } | undefined;
+        apps?: unknown;
+    } | null;
+    recurringEvent: import("@calcom/types/Calendar").RecurringEvent | null;
+    customInputs: {
+        id: number;
+        eventTypeId: number;
+        required: boolean;
+        label: string;
+        placeholder: string;
+        type: "TEXT" | "TEXTLONG" | "NUMBER" | "BOOL" | "RADIO" | "PHONE";
+        options?: {
+            label: string;
+            type: string;
+        }[] | null | undefined;
+        hasToBeCreated?: boolean | undefined;
+    }[];
+    locations: import('../../../../app-store/locations').LocationObject[];
+    bookingFields: {
+        name: string;
+        type: "number" | "boolean" | "select" | "text" | "checkbox" | "email" | "address" | "url" | "name" | "radio" | "textarea" | "phone" | "multiselect" | "multiemail" | "radioInput";
+        required?: boolean | undefined;
+        label?: string | undefined;
+        placeholder?: string | undefined;
+        options?: {
+            label: string;
+            value: string;
+        }[] | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        defaultLabel?: string | undefined;
+        defaultPlaceholder?: string | undefined;
+        getOptionsAt?: string | undefined;
+        optionsInputs?: Record<string, {
+            type: "text" | "address" | "phone";
+            required?: boolean | undefined;
+            placeholder?: string | undefined;
+        }> | undefined;
+        labelAsSafeHtml?: string | undefined;
+        excludeEmails?: string | undefined;
+        requireEmails?: string | undefined;
+        variant?: string | undefined;
+        variantsConfig?: {
+            variants: Record<string, {
+                fields: {
+                    name: string;
+                    type: "number" | "boolean" | "select" | "text" | "checkbox" | "email" | "address" | "url" | "name" | "radio" | "textarea" | "phone" | "multiselect" | "multiemail" | "radioInput";
+                    required?: boolean | undefined;
+                    label?: string | undefined;
+                    placeholder?: string | undefined;
+                    maxLength?: number | undefined;
+                    minLength?: number | undefined;
+                    labelAsSafeHtml?: string | undefined;
+                    excludeEmails?: string | undefined;
+                    requireEmails?: string | undefined;
+                }[];
+            }>;
+        } | undefined;
+        views?: {
+            id: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        hideWhenJustOneOption?: boolean | undefined;
+        hidden?: boolean | undefined;
+        editable?: "user" | "system-but-optional" | "system" | "user-readonly" | "system-but-hidden" | undefined;
+        sources?: {
+            id: string;
+            label: string;
+            type: string;
+            editUrl?: string | undefined;
+            fieldRequired?: boolean | undefined;
+        }[] | undefined;
+        disableOnPrefill?: boolean | undefined;
+    }[] & import("zod").BRAND<"HAS_SYSTEM_FIELDS">;
+    rrSegmentQueryValue: {
+        type: "group";
+        id?: string | undefined;
+        children1?: Record<string, {
+            type?: string | undefined;
+            properties?: {
+                field?: any;
+                operator?: any;
+                value?: any;
+                valueSrc?: any;
+                valueError?: (string | null)[] | undefined;
+                valueType?: any;
+            } | undefined;
+        }> | undefined;
+        properties?: any;
+    } | {
+        type: "switch_group";
+        id?: string | undefined;
+        children1?: Record<string, {
+            type?: string | undefined;
+            properties?: {
+                field?: any;
+                operator?: any;
+                value?: any;
+                valueSrc?: any;
+                valueError?: (string | null)[] | undefined;
+                valueType?: any;
+            } | undefined;
+        }> | undefined;
+        properties?: any;
+    } | null;
+    isDynamic: boolean;
+    length: number;
+    availability: {
+        date: Date | null;
+        days: number[];
+        startTime: Date;
+        endTime: Date;
+    }[];
+    id: number;
+    userId: number | null;
+    price: number;
+    owner: {
+        hideBranding: boolean;
+    } | null;
+    title: string;
+    description: string | null;
+    team: {
+        id: number;
+        name: string;
+        parentId: number | null;
+        bookingLimits: import('../../../../prisma-client').Prisma.JsonValue;
+        rrResetInterval: import('../../../../prisma-client').$Enums.RRResetInterval | null;
+        includeManagedEventsInLimits: boolean;
+    } | null;
+    workflows: {
+        workflow: {
+            id: number;
+            userId: number | null;
+            name: string;
+            trigger: import('../../../../prisma-client').$Enums.WorkflowTriggerEvents;
+            time: number | null;
+            teamId: number | null;
+            steps: {
+                id: number;
+                action: import('../../../../prisma-client').$Enums.WorkflowActions;
+                template: import('../../../../prisma-client').$Enums.WorkflowTemplates;
+                sender: string | null;
+                sendTo: string | null;
+                reminderBody: string | null;
+                emailSubject: string | null;
+                numberRequired: boolean | null;
+                numberVerificationPending: boolean;
+                includeCalendarEvent: boolean;
+                verifiedAt: Date | null;
+            }[];
+            timeUnit: import('../../../../prisma-client').$Enums.TimeUnit | null;
+        };
+    }[];
+    currency: string;
+    slug: string;
+    schedule: {
+        availability: {
+            date: Date | null;
+            days: number[];
+            startTime: Date;
+            endTime: Date;
+            id: number;
+            userId: number | null;
+            eventTypeId: number | null;
+            scheduleId: number | null;
+        }[];
+        id: number;
+        timeZone: string | null;
+    } | null;
+    destinationCalendar: {
+        id: number;
+        userId: number | null;
+        eventTypeId: number | null;
+        integration: string;
+        externalId: string;
+        primaryEmail: string | null;
+        credentialId: number | null;
+        delegationCredentialId: string | null;
+        domainWideDelegationCredentialId: string | null;
+    } | null;
+    secondaryEmail: {
+        id: number;
+        email: string;
+    } | null;
+    teamId: number | null;
+    useEventLevelSelectedCalendars: boolean;
+    eventName: string | null;
+    parentId: number | null;
+    timeZone: string | null;
+    periodType: import('../../../../prisma-client').$Enums.PeriodType;
+    periodStartDate: Date | null;
+    periodEndDate: Date | null;
+    periodDays: number | null;
+    periodCountCalendarDays: boolean | null;
+    lockTimeZoneToggleOnBookingPage: boolean;
+    requiresConfirmation: boolean;
+    requiresConfirmationForFreeEmail: boolean;
+    requiresBookerEmailVerification: boolean;
+    disableGuests: boolean;
+    hideCalendarNotes: boolean;
+    hideCalendarEventDetails: boolean;
+    minimumBookingNotice: number;
+    beforeEventBuffer: number;
+    afterEventBuffer: number;
+    seatsPerTimeSlot: number | null;
+    seatsShowAttendees: boolean | null;
+    seatsShowAvailabilityCount: boolean | null;
+    schedulingType: import('../../../../prisma-client').$Enums.SchedulingType | null;
+    bookingLimits: import('../../../../prisma-client').Prisma.JsonValue;
+    durationLimits: import('../../../../prisma-client').Prisma.JsonValue;
+    assignAllTeamMembers: boolean;
+    assignRRMembersUsingSegment: boolean;
+    useEventTypeDestinationCalendarEmail: boolean;
+    isRRWeightsEnabled: boolean;
+    maxLeadThreshold: number | null;
+    includeNoShowInRRCalculation: boolean;
+    hideOrganizerEmail: boolean;
+    customReplyToEmail: string | null;
+    rescheduleWithSameRoundRobinHost: boolean;
+    secondaryEmailId: number | null;
+    parent: {
+        team: {
+            id: number;
+            bookingLimits: import('../../../../prisma-client').Prisma.JsonValue;
+            includeManagedEventsInLimits: boolean;
+        } | null;
+        teamId: number | null;
+    } | null;
+}, "users"> & {
     users: IsFixedAwareUser[];
 }, input: {
     dateFrom: string;
     dateTo: string;
     timeZone: string;
     originalRescheduledBooking?: BookingType;
-}, loggerWithEventDetails: Logger<unknown>, shouldServeCache?: boolean): Promise<[IsFixedAwareUser, ...IsFixedAwareUser[]]>;
+}, loggerWithEventDetails: Logger<unknown>, shouldServeCache?: boolean | undefined) => Promise<[IsFixedAwareUser, ...IsFixedAwareUser[]]>;
 //# sourceMappingURL=ensureAvailableUsers.d.ts.map

package/dist/packages/features/bookings/lib/handleNewBooking/ensureAvailableUsers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ensureAvailableUsers.d.ts","sourceRoot":"","sources":["../../../../../../../../features/bookings/lib/handleNewBooking/ensureAvailableUsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAapC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAqChD,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC,GAAG;IAC/C,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC3B,EACD,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,0BAA0B,CAAC,EAAE,WAAW,CAAA;CAAE,EACvG,sBAAsB,EAAE,MAAM,CAAC,OAAO,CAAC,EACvC,gBAAgB,CAAC,EAAE,OAAO,GAEzB,OAAO,CAAC,CAAC,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,CAAC,CAAC,CAwGpD"}
+{"version":3,"file":"ensureAvailableUsers.d.ts","sourceRoot":"","sources":["../../../../../../../../features/bookings/lib/handleNewBooking/ensureAvailableUsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAepC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAuJhD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAhHtB,gBAAgB,EAAE;;cAER,MAAM;YAAU,MAAM;cAAY,MAAM;iCAA+B,WAAW;yIA8GP,CAAC"}

package/dist/packages/features/bookings/lib/handleNewBooking/findBookingQuery.d.ts

@@ -1,28 +1,28 @@
 export declare const findBookingQuery: (bookingId: number) => Promise<{
+    startTime: Date;
+    endTime: Date;
+    location: string | null;
+    title: string;
+    description: string | null;
+    status: import('../../../../prisma-client').$Enums.BookingStatus;
+    user: {
+        username: string | null;
+        email: string;
+        name: string | null;
+        timeZone: string;
+    } | null;
+    uid: string;
     eventType: {
         length: number;
+        price: number;
         title: string;
         description: string | null;
-        price: number;
         currency: string;
         lockTimeZoneToggleOnBookingPage: boolean;
         requiresConfirmation: boolean;
         requiresBookerEmailVerification: boolean;
     } | null;
-    user: {
-        name: string | null;
-        username: string | null;
-        email: string;
-        timeZone: string;
-    } | null;
-    title: string;
     metadata: import('../../../../prisma-client').Prisma.JsonValue;
-    status: import('../../../../prisma-client').$Enums.BookingStatus;
-    description: string | null;
-    location: string | null;
-    uid: string;
     responses: import('../../../../prisma-client').Prisma.JsonValue;
-    startTime: Date;
-    endTime: Date;
 }>;
 //# sourceMappingURL=findBookingQuery.d.ts.map

package/dist/packages/features/bookings/lib/handleNewBooking/findBookingQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findBookingQuery.d.ts","sourceRoot":"","sources":["../../../../../../../../features/bookings/lib/handleNewBooking/findBookingQuery.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,cAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;EA6CvD,CAAC"}
+{"version":3,"file":"findBookingQuery.d.ts","sourceRoot":"","sources":["../../../../../../../../features/bookings/lib/handleNewBooking/findBookingQuery.ts"],"names":[],"mappings":"AAmDA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;EAAuD,CAAC"}