@calcom/atoms 1.0.96 → 1.0.97-beta-2

package/dist/packages/features/ee/payments/components/Payment.d.ts

@@ -0,0 +1,41 @@
+import type { EventType, Payment } from '../../../../prisma-client';
+import type { StripeElements } from "@stripe/stripe-js";
+import type { SyntheticEvent } from "react";
+import type { PaymentOption } from '../../../../prisma/enums';
+import type { PaymentPageProps } from "../pages/payment";
+export type Props = {
+    payment: Omit<Payment, "id" | "fee" | "success" | "refunded" | "externalId" | "data"> & {
+        data: Record<string, unknown>;
+    };
+    eventType: {
+        id: number;
+        successRedirectUrl: EventType["successRedirectUrl"];
+        forwardParamsSuccessRedirect: EventType["forwardParamsSuccessRedirect"];
+    };
+    user: {
+        username: string | null;
+    };
+    location?: string | null;
+    clientSecret: string;
+    booking: PaymentPageProps["booking"];
+};
+export type States = {
+    status: "idle";
+} | {
+    status: "processing";
+} | {
+    status: "error";
+    error: Error;
+} | {
+    status: "ok";
+};
+export declare const PaymentFormComponent: (props: Props & {
+    onSubmit: (ev: SyntheticEvent) => void;
+    onCancel: () => void;
+    onPaymentElementChange: () => void;
+    elements: StripeElements | null;
+    paymentOption: PaymentOption | null;
+    state: States;
+}) => JSX.Element;
+export default function PaymentComponent(props: Props): JSX.Element;
+//# sourceMappingURL=Payment.d.ts.map

package/dist/packages/features/ee/payments/components/Payment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Payment.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/payments/components/Payment.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,KAAK,EAAuB,cAAc,EAA+B,MAAM,mBAAmB,CAAC;AAE1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAQ5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,KAAK,GAAG,SAAS,GAAG,UAAU,GAAG,YAAY,GAAG,MAAM,CAAC,GAAG;QACtF,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC/B,CAAC;IACF,SAAS,EAAE;QACT,EAAE,EAAE,MAAM,CAAC;QACX,kBAAkB,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;QACpD,4BAA4B,EAAE,SAAS,CAAC,8BAA8B,CAAC,CAAC;KACzE,CAAC;IACF,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,MAAM,GACd;IACE,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,MAAM,EAAE,YAAY,CAAC;CACtB,GACD;IACE,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;CACd,GACD;IACE,MAAM,EAAE,IAAI,CAAC;CACd,CAAC;AAEN,eAAO,MAAM,oBAAoB,UACxB,KAAK,GAAG;IACb,QAAQ,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAChC,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf,gBAsEF,CAAC;AA4GF,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,KAAK,EAAE,KAAK,eAsBpD"}

package/dist/packages/features/ee/payments/components/PaymentPage.d.ts

@@ -0,0 +1,5 @@
+import type { FC } from "react";
+import type { PaymentPageProps } from "../pages/payment";
+declare const PaymentPage: FC<PaymentPageProps>;
+export default PaymentPage;
+//# sourceMappingURL=PaymentPage.d.ts.map

package/dist/packages/features/ee/payments/components/PaymentPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PaymentPage.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/payments/components/PaymentPage.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC;AAgBhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAiCzD,QAAA,MAAM,WAAW,EAAE,EAAE,CAAC,gBAAgB,CAqIrC,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/packages/features/ee/payments/pages/getClientSecretFromPayment.d.ts

@@ -0,0 +1,5 @@
+import type { Payment } from '../../../../prisma-client';
+export declare function getClientSecretFromPayment(payment: Omit<Partial<Payment>, "data"> & {
+    data: Record<string, unknown>;
+}): string;
+//# sourceMappingURL=getClientSecretFromPayment.d.ts.map

package/dist/packages/features/ee/payments/pages/getClientSecretFromPayment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClientSecretFromPayment.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/payments/pages/getClientSecretFromPayment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAMrD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,UAa5E"}

package/dist/packages/features/ee/payments/pages/payment.d.ts

@@ -0,0 +1,214 @@
+import type { GetServerSidePropsContext } from "next";
+import type { inferSSRProps } from "@calcom/types/inferSSRProps";
+export type PaymentPageProps = inferSSRProps<typeof getServerSideProps>;
+export declare const getServerSideProps: (context: GetServerSidePropsContext) => Promise<{
+    readonly notFound: true;
+    redirect?: undefined;
+    props?: undefined;
+} | {
+    redirect: {
+        destination: string;
+        permanent: boolean;
+    };
+    notFound?: undefined;
+    props?: undefined;
+} | {
+    props: {
+        user: {
+            name: string | null;
+            username: string | null;
+            theme: string | null;
+            hideBranding: boolean;
+        } | {
+            name: null;
+            theme: null;
+            hideBranding: null;
+            username: null;
+        };
+        eventType: {
+            metadata: {
+                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?: {
+                        schedule?: true | undefined;
+                        profile?: true | undefined;
+                        bookings?: true | undefined;
+                        users?: true | undefined;
+                        children?: true | undefined;
+                        length?: true | undefined;
+                        title?: true | undefined;
+                        metadata?: true | undefined;
+                        description?: true | undefined;
+                        price?: true | undefined;
+                        webhooks?: true | undefined;
+                        owner?: true | undefined;
+                        hidden?: true | undefined;
+                        team?: true | undefined;
+                        availability?: true | undefined;
+                        workflows?: true | undefined;
+                        hosts?: true | undefined;
+                        currency?: true | undefined;
+                        slug?: true | undefined;
+                        userId?: 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;
+                        seatsShowAttendees?: true | undefined;
+                        seatsShowAvailabilityCount?: true | undefined;
+                        schedulingType?: true | undefined;
+                        scheduleId?: 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;
+                        allowReschedulingPastBookings?: true | undefined;
+                        eventTypeColor?: true | undefined;
+                        rescheduleWithSameRoundRobinHost?: true | undefined;
+                        secondaryEmailId?: true | undefined;
+                        hashedLink?: true | undefined;
+                        destinationCalendar?: true | undefined;
+                        customInputs?: true | undefined;
+                        parent?: true | undefined;
+                        instantMeetingSchedule?: true | undefined;
+                        aiPhoneCallConfig?: true | undefined;
+                        fieldTranslations?: true | undefined;
+                        selectedCalendars?: true | undefined;
+                        secondaryEmail?: true | undefined;
+                        _count?: true | undefined;
+                    } | undefined;
+                } | undefined;
+                requiresConfirmationThreshold?: {
+                    time: number;
+                    unit: "months" | "years" | "days" | "hours" | "minutes" | "milliseconds" | "seconds" | "dates";
+                } | undefined;
+                bookerLayouts?: {
+                    enabledLayouts: import('../../../../prisma/zod-utils').BookerLayouts[];
+                    defaultLayout: import('../../../../prisma/zod-utils').BookerLayouts;
+                } | null | undefined;
+                apps?: unknown;
+            } | null;
+            users: {
+                name: string | null;
+                username: string | null;
+                theme: string | null;
+                hideBranding: boolean;
+            }[];
+            id: number;
+            length: number;
+            title: string;
+            description: string | null;
+            price: number;
+            team: {
+                name: string;
+                hideBranding: boolean;
+            } | null;
+            currency: string;
+            userId: number | null;
+            eventName: string | null;
+            requiresConfirmation: boolean;
+            successRedirectUrl: string | null;
+            forwardParamsSuccessRedirect: boolean | null;
+        };
+        booking: {
+            startTime: string;
+            endTime: string;
+            user: {
+                name: string | null;
+                timeZone: string;
+            } | null;
+            id: number;
+            title: string;
+            status: import('../../../../prisma-client').$Enums.BookingStatus;
+            description: string | null;
+            location: string | null;
+            attendees: {
+                name: string;
+                email: string;
+                timeZone: string;
+            }[];
+            uid: string;
+            eventTypeId: number | null;
+            cancellationReason: string | null;
+            responses: import('../../../../prisma-client').Prisma.JsonValue;
+            rejectionReason: string | null;
+        };
+        trpcState: import("@tanstack/query-core").DehydratedState;
+        payment: {
+            data: Record<string, unknown>;
+            success: boolean;
+            refunded: boolean;
+            currency: string;
+            uid: string;
+            paymentOption: import('../../../../prisma-client').$Enums.PaymentOption | null;
+            bookingId: number;
+            appId: string | null;
+            amount: number;
+        };
+        clientSecret: string;
+        profile: {
+            name: string | null;
+            theme: string | null;
+            hideBranding: true | null;
+        };
+    };
+    notFound?: undefined;
+    redirect?: undefined;
+}>;
+//# sourceMappingURL=payment.d.ts.map

package/dist/packages/features/ee/payments/pages/payment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/payments/pages/payment.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,MAAM,CAAC;AAQtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAIjE,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMxE,eAAO,MAAM,kBAAkB,YAAmB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBzD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;EAoDxC,CAAC"}

package/dist/packages/features/ee/payments/server/stripe.d.ts

@@ -0,0 +1,7 @@
+import Stripe from "stripe";
+declare global {
+    var stripe: Stripe | undefined;
+}
+declare const stripe: Stripe;
+export default stripe;
+//# sourceMappingURL=stripe.d.ts.map

package/dist/packages/features/ee/payments/server/stripe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripe.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/payments/server/stripe.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,QAAA,MAAM,MAAM,QAIR,CAAC;AAML,eAAe,MAAM,CAAC"}

package/dist/packages/features/ee/round-robin/assignmentReason/AssignmentReasonRecorder.d.ts

@@ -0,0 +1,21 @@
+export default class AssignmentReasonRecorder {
+    static routingFormRoute({ bookingId, routingFormResponseId, organizerId, teamId, }: {
+        bookingId: number;
+        routingFormResponseId: number;
+        organizerId: number;
+        teamId: number;
+    }): Promise<void>;
+    static CRMOwnership({ bookingId, crmAppSlug, teamMemberEmail, recordType, routingFormResponseId, }: {
+        bookingId: number;
+        crmAppSlug: string;
+        teamMemberEmail: string;
+        recordType: string;
+        routingFormResponseId: number;
+    }): Promise<void>;
+    static roundRobinReassignment({ bookingId, reassignById, reassignReason, }: {
+        bookingId: number;
+        reassignById: number;
+        reassignReason?: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=AssignmentReasonRecorder.d.ts.map

package/dist/packages/features/ee/round-robin/assignmentReason/AssignmentReasonRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssignmentReasonRecorder.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/round-robin/assignmentReason/AssignmentReasonRecorder.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,OAAO,OAAO,wBAAwB;WAC9B,gBAAgB,CAAC,EAC5B,SAAS,EACT,qBAAqB,EACrB,WAAW,EACX,MAAM,GACP,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;KAChB;WA2FY,YAAY,CAAC,EACxB,SAAS,EACT,UAAU,EACV,eAAe,EACf,UAAU,EACV,qBAAqB,GACtB,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,eAAe,EAAE,MAAM,CAAC;QACxB,UAAU,EAAE,MAAM,CAAC;QACnB,qBAAqB,EAAE,MAAM,CAAC;KAC/B;WAkBY,sBAAsB,CAAC,EAClC,SAAS,EACT,YAAY,EACZ,cAAc,GACf,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CAsBF"}

package/dist/packages/features/ee/round-robin/assignmentReason/appAssignmentReasonHandler.d.ts

@@ -0,0 +1,12 @@
+import type { AssignmentReasonEnum } from '../../../../prisma/enums';
+type AppAssignmentReasonHandler = ({ recordType, teamMemberEmail, routingFormResponseId, }: {
+    recordType: string;
+    teamMemberEmail: string;
+    routingFormResponseId: number;
+}) => Promise<{
+    assignmentReason: string | undefined;
+    reasonEnum: AssignmentReasonEnum;
+} | undefined>;
+declare const appBookingFormHandler: Record<string, AppAssignmentReasonHandler>;
+export default appBookingFormHandler;
+//# sourceMappingURL=appAssignmentReasonHandler.d.ts.map

package/dist/packages/features/ee/round-robin/assignmentReason/appAssignmentReasonHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appAssignmentReasonHandler.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/round-robin/assignmentReason/appAssignmentReasonHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,KAAK,0BAA0B,GAAG,CAAC,EACjC,UAAU,EACV,eAAe,EACf,qBAAqB,GACtB,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;CAC/B,KAAK,OAAO,CAAC;IAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,UAAU,EAAE,oBAAoB,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC;AAEtG,QAAA,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAErE,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/packages/features/ee/round-robin/handleRescheduleEventManager.d.ts

@@ -0,0 +1,90 @@
+import type { DestinationCalendar } from '../../../prisma-client';
+import type { Prisma } from '../../../prisma-client';
+import type { EventType } from '../../bookings/lib/getAllCredentialsForUsersOnEvent/getAllCredentials';
+import type { EventManagerInitParams } from '../../../lib/EventManager';
+import type { CalendarEvent, AdditionalInformation } from "@calcom/types/Calendar";
+type InitParams = {
+    user: {
+        id: number;
+        name: string | null;
+        email: string;
+        username: string | null;
+    } & EventManagerInitParams["user"];
+    eventTypeAppMetadata?: EventManagerInitParams["eventTypeAppMetadata"];
+    eventType: EventType;
+};
+export declare const handleRescheduleEventManager: ({ evt, rescheduleUid, newBookingId, changedOrganizer, previousHostDestinationCalendar, initParams, bookingLocation, bookingId, bookingICalUID, bookingMetadata, }: {
+    evt: CalendarEvent;
+    rescheduleUid: string;
+    newBookingId?: number;
+    changedOrganizer?: boolean;
+    previousHostDestinationCalendar?: DestinationCalendar[] | null;
+    initParams: InitParams;
+    bookingLocation: string | null;
+    bookingId: number;
+    bookingICalUID?: string | null;
+    bookingMetadata?: Prisma.JsonValue;
+}) => Promise<{
+    evtWithAdditionalInfo: {
+        additionalInformation: AdditionalInformation;
+        bookerUrl?: string;
+        type: string;
+        title: string;
+        startTime: string;
+        endTime: string;
+        organizer: import("@calcom/types/Calendar").Person;
+        attendees: import("@calcom/types/Calendar").Person[];
+        length?: number | null;
+        additionalNotes?: string | null;
+        customInputs?: Prisma.JsonObject | null;
+        description?: string | null;
+        team?: {
+            name: string;
+            members: import("@calcom/types/Calendar").TeamMember[];
+            id: number;
+        };
+        location?: string | null;
+        conferenceCredentialId?: number;
+        conferenceData?: import("@calcom/types/Calendar").ConferenceData;
+        uid?: string | null;
+        existingRecurringEvent?: import("@calcom/types/Calendar").ExistingRecurringEvent | null;
+        bookingId?: number;
+        videoCallData?: any;
+        paymentInfo?: {
+            link?: string | null;
+            reason?: string | null;
+            id?: string | null;
+            paymentOption?: string | null;
+            amount?: number;
+            currency?: string;
+        } | null;
+        requiresConfirmation?: boolean | null;
+        destinationCalendar?: DestinationCalendar[] | null;
+        cancellationReason?: string | null;
+        rejectionReason?: string | null;
+        hideCalendarNotes?: boolean;
+        hideCalendarEventDetails?: boolean;
+        recurrence?: string;
+        recurringEvent?: import("@calcom/types/Calendar").RecurringEvent | null;
+        eventTypeId?: number | null;
+        appsStatus?: import("@calcom/types/Calendar").AppsStatus[];
+        seatsShowAttendees?: boolean | null;
+        seatsShowAvailabilityCount?: boolean | null;
+        attendeeSeatId?: string;
+        seatsPerTimeSlot?: number | null;
+        schedulingType?: import("@calcom/platform-libraries").SchedulingType | null;
+        iCalUID?: string | null;
+        iCalSequence?: number | null;
+        responses?: import("@calcom/types/Calendar").CalEventResponses | null;
+        userFieldsResponses?: import("@calcom/types/Calendar").CalEventResponses | null;
+        platformClientId?: string | null;
+        platformRescheduleUrl?: string | null;
+        platformCancelUrl?: string | null;
+        platformBookingUrl?: string | null;
+        oneTimePassword?: string | null;
+        delegationCredentialId?: string | null;
+        domainWideDelegationCredentialId?: string | null;
+    };
+}>;
+export {};
+//# sourceMappingURL=handleRescheduleEventManager.d.ts.map

package/dist/packages/features/ee/round-robin/handleRescheduleEventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleRescheduleEventManager.d.ts","sourceRoot":"","sources":["../../../../../../../features/ee/round-robin/handleRescheduleEventManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAK7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kFAAkF,CAAC;AAIlH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAKvE,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAEnF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE;QACJ,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;KACzB,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;IACnC,oBAAoB,CAAC,EAAE,sBAAsB,CAAC,sBAAsB,CAAC,CAAC;IACtE,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,4BAA4B,sKAWtC;IACD,GAAG,EAAE,aAAa,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,+BAA+B,CAAC,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAAC;IAC/D,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6IA,CAAC"}

package/dist/packages/features/ee/round-robin/roundRobinManualReassignment.d.ts

@@ -0,0 +1,120 @@
+import type { PlatformClientParams } from '../../../prisma/zod-utils';
+export declare const roundRobinManualReassignment: ({ bookingId, newUserId, orgId, reassignReason, reassignedById, emailsEnabled, platformClientParams, }: {
+    bookingId: number;
+    newUserId: number;
+    orgId: number | null;
+    reassignReason?: string;
+    reassignedById: number;
+    emailsEnabled?: boolean;
+    platformClientParams?: PlatformClientParams;
+}) => Promise<{
+    user: ({
+        destinationCalendar: {
+            id: number;
+            userId: number | null;
+            credentialId: number | null;
+            eventTypeId: number | null;
+            integration: string;
+            externalId: string;
+            primaryEmail: string | null;
+            delegationCredentialId: string | null;
+            domainWideDelegationCredentialId: string | null;
+        } | null;
+    } & {
+        name: string | null;
+        id: number;
+        role: import('../../../prisma-client').$Enums.UserPermissionRole;
+        metadata: import('../../../prisma-client').Prisma.JsonValue;
+        username: string | null;
+        email: string;
+        bio: string | null;
+        theme: string | null;
+        verified: boolean | null;
+        locked: boolean;
+        organizationId: number | null;
+        locale: string | null;
+        timeZone: string;
+        startTime: number;
+        endTime: number;
+        creationSource: import('../../../prisma-client').$Enums.CreationSource | null;
+        movedToProfileId: number | null;
+        emailVerified: Date | null;
+        avatarUrl: string | null;
+        weekStart: string;
+        bufferTime: number;
+        hideBranding: boolean;
+        appTheme: string | null;
+        createdDate: Date;
+        trialEndsAt: Date | null;
+        lastActiveAt: Date | null;
+        defaultScheduleId: number | null;
+        completedOnboarding: boolean;
+        timeFormat: number | null;
+        twoFactorSecret: string | null;
+        twoFactorEnabled: boolean;
+        backupCodes: string | null;
+        identityProvider: import('../../../prisma-client').$Enums.IdentityProvider;
+        identityProviderId: string | null;
+        invitedTo: number | null;
+        brandColor: string | null;
+        darkBrandColor: string | null;
+        allowDynamicBooking: boolean | null;
+        allowSEOIndexing: boolean | null;
+        receiveMonthlyDigestEmail: boolean | null;
+        disableImpersonation: boolean;
+        isPlatformManaged: boolean;
+        smsLockState: import('../../../prisma-client').$Enums.SMSLockState;
+        smsLockReviewedByAdmin: boolean;
+        referralLinkId: string | null;
+    }) | null;
+    title: string;
+    metadata: import('../../../prisma-client').Prisma.JsonValue;
+    description: string | null;
+    location: string | null;
+    attendees: {
+        name: string;
+        id: number;
+        email: string;
+        locale: string | null;
+        timeZone: string;
+        bookingId: number | null;
+        phoneNumber: string | null;
+        noShow: boolean | null;
+    }[];
+    uid: string;
+    userId: number | null;
+    eventTypeId: number | null;
+    destinationCalendar: {
+        id: number;
+        userId: number | null;
+        credentialId: number | null;
+        eventTypeId: number | null;
+        integration: string;
+        externalId: string;
+        primaryEmail: string | null;
+        delegationCredentialId: string | null;
+        domainWideDelegationCredentialId: string | null;
+    } | null;
+    customInputs: import('../../../prisma-client').Prisma.JsonValue;
+    iCalUID: string | null;
+    responses: import('../../../prisma-client').Prisma.JsonValue;
+    references: {
+        id: number;
+        type: string;
+        uid: string;
+        credentialId: number | null;
+        deleted: boolean | null;
+        bookingId: number | null;
+        thirdPartyRecurringEventId: string | null;
+        delegationCredentialId: string | null;
+        domainWideDelegationCredentialId: string | null;
+        meetingId: string | null;
+        meetingPassword: string | null;
+        meetingUrl: string | null;
+        externalCalendarId: string | null;
+    }[];
+    startTime: Date;
+    endTime: Date;
+}>;
+export default roundRobinManualReassignment;
+//# sourceMappingURL=roundRobinManualReassignment.d.ts.map

package/dist/packages/features/ee/round-robin/roundRobinManualReassignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundRobinManualReassignment.d.ts","sourceRoot":"","sources":["../../../../../../../features/ee/round-robin/roundRobinManualReassignment.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAcxF,eAAO,MAAM,4BAA4B,0GAQtC;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuTA,CAAC;AA0JF,eAAe,4BAA4B,CAAC"}

package/dist/packages/features/ee/round-robin/roundRobinManualReassignment.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roundRobinManualReassignment.test.d.ts.map

package/dist/packages/features/ee/round-robin/roundRobinManualReassignment.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundRobinManualReassignment.test.d.ts","sourceRoot":"","sources":["../../../../../../../features/ee/round-robin/roundRobinManualReassignment.test.ts"],"names":[],"mappings":""}

package/dist/packages/features/ee/round-robin/roundRobinReassignment.d.ts

@@ -0,0 +1,16 @@
+import type { PlatformClientParams } from '../../../prisma/zod-utils';
+export declare const roundRobinReassignment: ({ bookingId, orgId, emailsEnabled, platformClientParams, }: {
+    bookingId: number;
+    orgId: number | null;
+    emailsEnabled?: boolean;
+    platformClientParams?: PlatformClientParams;
+}) => Promise<{
+    bookingId: number;
+    reassignedTo: {
+        id: number;
+        name: string | null;
+        email: string;
+    };
+}>;
+export default roundRobinReassignment;
+//# sourceMappingURL=roundRobinReassignment.d.ts.map

package/dist/packages/features/ee/round-robin/roundRobinReassignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundRobinReassignment.d.ts","sourceRoot":"","sources":["../../../../../../../features/ee/round-robin/roundRobinReassignment.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAqB,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAQxF,eAAO,MAAM,sBAAsB,+DAKhC;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;;;;;;;EA2fA,CAAC;AAEF,eAAe,sBAAsB,CAAC"}

package/dist/packages/features/ee/round-robin/roundRobinReassignment.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roundRobinReassignment.test.d.ts.map

package/dist/packages/features/ee/round-robin/roundRobinReassignment.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundRobinReassignment.test.d.ts","sourceRoot":"","sources":["../../../../../../../features/ee/round-robin/roundRobinReassignment.test.ts"],"names":[],"mappings":""}

package/dist/packages/features/ee/round-robin/utils/bookingSelect.d.ts

@@ -0,0 +1,27 @@
+import type { Prisma } from '../../../../prisma-client';
+export declare const bookingSelect: {
+    uid: boolean;
+    title: boolean;
+    startTime: boolean;
+    endTime: boolean;
+    userId: boolean;
+    customInputs: boolean;
+    responses: boolean;
+    description: boolean;
+    location: boolean;
+    eventTypeId: boolean;
+    destinationCalendar: boolean;
+    user: {
+        include: {
+            destinationCalendar: boolean;
+        };
+    };
+    attendees: boolean;
+    references: boolean;
+    metadata: boolean;
+    iCalUID: boolean;
+};
+export type BookingSelectResult = Prisma.BookingGetPayload<{
+    select: typeof bookingSelect;
+}>;
+//# sourceMappingURL=bookingSelect.d.ts.map

package/dist/packages/features/ee/round-robin/utils/bookingSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookingSelect.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/round-robin/utils/bookingSelect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAqBzB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,iBAAiB,CAAC;IACzD,MAAM,EAAE,OAAO,aAAa,CAAC;CAC9B,CAAC,CAAC"}

package/dist/packages/features/ee/round-robin/utils/getDestinationCalendar.d.ts

@@ -0,0 +1,10 @@
+import type { getEventTypesFromDB } from '../../../bookings/lib/handleNewBooking/getEventTypesFromDB';
+import type { DestinationCalendar } from '../../../../prisma-client';
+import type { BookingSelectResult } from "./bookingSelect";
+export declare function getDestinationCalendar({ eventType, booking, newUserId, hasOrganizerChanged, }: {
+    eventType?: Awaited<ReturnType<typeof getEventTypesFromDB>>;
+    booking?: BookingSelectResult;
+    newUserId?: number;
+    hasOrganizerChanged: boolean;
+}): Promise<DestinationCalendar[] | undefined>;
+//# sourceMappingURL=getDestinationCalendar.d.ts.map

package/dist/packages/features/ee/round-robin/utils/getDestinationCalendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDestinationCalendar.d.ts","sourceRoot":"","sources":["../../../../../../../../features/ee/round-robin/utils/getDestinationCalendar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oEAAoE,CAAC;AAE9G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,wBAAsB,sBAAsB,CAAC,EAC3C,SAAS,EACT,OAAO,EACP,SAAS,EACT,mBAAmB,GACpB,EAAE;IACD,SAAS,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,GAAG,OAAO,CAAC,mBAAmB,EAAE,GAAG,SAAS,CAAC,CAmB7C"}