export declare const bookingsRouter: import("@trpc/server/unstable-core-do-not-import").CreateRouterInner<import("@trpc/server/unstable-core-do-not-import").RootConfig<{
    ctx: import("../../../createContext").InnerContext;
    meta: object;
    errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
    transformer: {
        stringify: (object: any) => string;
        parse: <T = unknown>(string: string) => T;
        serialize: (object: any) => import("superjson/dist/types").SuperJSONResult;
        deserialize: <T_1 = unknown>(payload: import("superjson/dist/types").SuperJSONResult) => T_1;
        registerClass: (v: import("superjson/dist/types").Class, options?: string | import("superjson/dist/class-registry").RegisterOptions | undefined) => void;
        registerSymbol: (v: Symbol, identifier?: string | undefined) => void;
        registerCustom: <I, O extends import("superjson/dist/types").JSONValue>(transformer: Omit<import("superjson/dist/custom-transformer-registry").CustomTransfomer<I, O>, "name">, name: string) => void;
        allowErrorProps: (...props: string[]) => void;
    };
}>, {
    get: import("@trpc/server/unstable-core-do-not-import").QueryProcedure<{
        input: {
            offset: number;
            filters: {
                teamIds?: number[] | undefined;
                userIds?: number[] | undefined;
                status?: "upcoming" | "recurring" | "past" | "unconfirmed" | "cancelled" | undefined;
                eventTypeIds?: number[] | undefined;
                attendeeEmail?: string | {
                    data: {
                        operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
                        operand: string;
                    };
                    type: import('../../../../../features/data-table').ColumnFilterType.TEXT;
                } | undefined;
                attendeeName?: string | {
                    data: {
                        operator: "endsWith" | "startsWith" | "equals" | "contains" | "notEquals" | "notContains" | "isEmpty" | "isNotEmpty";
                        operand: string;
                    };
                    type: import('../../../../../features/data-table').ColumnFilterType.TEXT;
                } | undefined;
                afterStartDate?: string | undefined;
                beforeEndDate?: string | undefined;
                afterUpdatedDate?: string | undefined;
                beforeUpdatedDate?: string | undefined;
                afterCreatedDate?: string | undefined;
                beforeCreatedDate?: string | undefined;
            };
            limit: number;
        };
        output: {
            bookings: {
                eventType: {
                    recurringEvent: import("@calcom/types/Calendar").RecurringEvent | null;
                    eventTypeColor: {
                        lightEventTypeColor: string;
                        darkEventTypeColor: string;
                    } | null;
                    price: number;
                    currency: string;
                    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;
                    id?: number | undefined;
                    length?: number | undefined;
                    title?: string | undefined;
                    team?: {
                        name: string;
                        id: number;
                        slug: string | null;
                    } | null | undefined;
                    slug?: string | undefined;
                    eventName?: string | null | undefined;
                    disableGuests?: boolean | undefined;
                    seatsShowAttendees?: boolean | null | undefined;
                    seatsShowAvailabilityCount?: boolean | null | undefined;
                    schedulingType?: import('../../../../../prisma-client').$Enums.SchedulingType | null | undefined;
                    allowReschedulingPastBookings?: boolean | undefined;
                };
                startTime: string;
                endTime: string;
                user: {
                    name: string | null;
                    id: number;
                    email: string;
                } | null;
                id: number;
                title: string;
                metadata: import('../../../../../prisma-client').Prisma.JsonValue;
                status: import('../../../../../prisma-client').$Enums.BookingStatus;
                description: string | null;
                paid: boolean;
                payment: {
                    success: boolean;
                    currency: string;
                    paymentOption: import('../../../../../prisma-client').$Enums.PaymentOption | null;
                    amount: number;
                }[];
                location: string | null;
                attendees: {
                    name: string;
                    id: number;
                    email: string;
                    locale: string | null;
                    timeZone: string;
                    bookingId: number | null;
                    phoneNumber: string | null;
                    noShow: boolean | null;
                }[];
                rescheduled: boolean | null;
                uid: string;
                customInputs: import('../../../../../prisma-client').Prisma.JsonValue;
                recurringEventId: string | null;
                responses: import('../../../../../prisma-client').Prisma.JsonValue;
                assignmentReason: {
                    id: number;
                    bookingId: number;
                    createdAt: Date;
                    reasonEnum: import('../../../../../prisma-client').$Enums.AssignmentReasonEnum;
                    reasonString: string;
                }[];
                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;
                }[];
                seatsReferences: {
                    attendee: {
                        email: string;
                    };
                    referenceUid: string;
                }[];
                routedFromRoutingFormReponse: {
                    id: number;
                } | null;
                userPrimaryEmail: string | null;
                isRecorded: boolean;
            }[];
            recurringInfo: {
                recurringEventId: string | null;
                count: number;
                firstDate: Date | null;
                bookings: {
                    [key: string]: Date[];
                };
            }[];
            totalCount: number;
        };
    }>;
    requestReschedule: import("@trpc/server/unstable-core-do-not-import").MutationProcedure<{
        input: {
            bookingId: string;
            rescheduleReason?: string | undefined;
        };
        output: void;
    }>;
    editLocation: import("@trpc/server/unstable-core-do-not-import").MutationProcedure<{
        input: {
            bookingId: number;
            credentialId: number | null;
            newLocation: string;
        };
        output: {
            message: string;
        };
    }>;
    addGuests: import("@trpc/server/unstable-core-do-not-import").MutationProcedure<{
        input: {
            guests: string[];
            bookingId: number;
        };
        output: {
            message: string;
        };
    }>;
    confirm: import("@trpc/server/unstable-core-do-not-import").MutationProcedure<{
        input: {
            bookingId: number;
            confirmed: boolean;
            recurringEventId?: string | undefined;
            reason?: string | undefined;
            emailsEnabled?: boolean | undefined;
            platformClientParams?: {
                platformClientId?: string | undefined;
                platformRescheduleUrl?: string | null | undefined;
                platformCancelUrl?: string | null | undefined;
                platformBookingUrl?: string | null | undefined;
                platformBookingLocation?: string | undefined;
            } | undefined;
        };
        output: {
            message: string;
            status: "ACCEPTED" | "REJECTED";
        };
    }>;
    getBookingAttendees: import("@trpc/server/unstable-core-do-not-import").QueryProcedure<{
        input: {
            seatReferenceUid: string;
        };
        output: number;
    }>;
    find: import("@trpc/server/unstable-core-do-not-import").QueryProcedure<{
        input: {
            bookingUid?: string | undefined;
        };
        output: {
            booking: {
                id: number;
                status: import('../../../../../prisma-client').$Enums.BookingStatus;
                description: string | null;
                paid: boolean;
                uid: string;
                eventTypeId: number | null;
                startTime: Date;
                endTime: Date;
            } | null;
        };
    }>;
    getInstantBookingLocation: import("@trpc/server/unstable-core-do-not-import").QueryProcedure<{
        input: {
            bookingId: number;
        };
        output: {
            booking: {
                id: number;
                metadata: import('../../../../../prisma-client').Prisma.JsonValue;
                status: import('../../../../../prisma-client').$Enums.BookingStatus;
                description: string | null;
                location: string | null;
                uid: string;
                eventTypeId: number | null;
                startTime: Date;
                endTime: Date;
            } | null;
        };
    }>;
}>;
//# sourceMappingURL=_router.d.ts.map