bookito-widget 0.43.1 → 1.0.0-beta.2

package/dist/src/features/booking-flow/components/BookingDetailsSection.vue.d.ts

@@ -0,0 +1,30 @@
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+type __VLS_Props = {
+    canContinue: boolean;
+    form: BookingFormStateType;
+    hasPms: boolean;
+    isSubmitting?: boolean;
+    language: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    next: () => any;
+    "update:phoneNumber": (value: string) => any;
+    "update:bookingReference": (value: string) => any;
+    "update:communicationLanguage": (value: string) => any;
+    "update:dateOfBirth": (value: string) => any;
+    "update:guestEmail": (value: string) => any;
+    "update:guestName": (value: string) => any;
+    "update:phoneDialCode": (value: string) => any;
+    "update:roomNumber": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNext?: (() => any) | undefined;
+    "onUpdate:phoneNumber"?: ((value: string) => any) | undefined;
+    "onUpdate:bookingReference"?: ((value: string) => any) | undefined;
+    "onUpdate:communicationLanguage"?: ((value: string) => any) | undefined;
+    "onUpdate:dateOfBirth"?: ((value: string) => any) | undefined;
+    "onUpdate:guestEmail"?: ((value: string) => any) | undefined;
+    "onUpdate:guestName"?: ((value: string) => any) | undefined;
+    "onUpdate:phoneDialCode"?: ((value: string) => any) | undefined;
+    "onUpdate:roomNumber"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingDetailsTextInput.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    autocomplete?: string;
+    inputmode?: 'text' | 'email' | 'tel' | 'numeric';
+    modelValue: string;
+    placeholder?: string;
+    type?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLInputElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingExtras.vue.d.ts

@@ -0,0 +1,15 @@
+import { BookitoPriceVariantType } from '../../../../features/event-feed/model/widget.types';
+import { SupportedLanguageType } from '../../../../shared/config/languages';
+type __VLS_Props = {
+    currency: string;
+    disabled?: boolean;
+    language: SupportedLanguageType;
+    priceVariants: BookitoPriceVariantType[];
+    selectedPriceVariantIds: string[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "toggle-price-variant": (variantId: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onToggle-price-variant"?: ((variantId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingFlowNextButton.vue.d.ts

@@ -0,0 +1,10 @@
+type __VLS_Props = {
+    disabled?: boolean;
+    label: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingFlowPanel.vue.d.ts

@@ -0,0 +1,7 @@
+import { BookingFlowPanelPropsType } from '../../../../features/booking-flow/components/booking-flow.props';
+declare const _default: import('vue').DefineComponent<BookingFlowPanelPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    completed: () => any;
+}, string, import('vue').PublicProps, Readonly<BookingFlowPanelPropsType> & Readonly<{
+    onCompleted?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingFlowStepper.vue.d.ts

@@ -0,0 +1,13 @@
+import { BookingDisplayStepEntryType, BookingDisplayStepType } from '../../../../features/booking-flow/model/booking-display-step.types';
+type __VLS_Props = {
+    activeStep: BookingDisplayStepType;
+    canGoToStep: (stepId: BookingDisplayStepType) => boolean;
+    isStepComplete: (stepId: BookingDisplayStepType) => boolean;
+    steps: BookingDisplayStepEntryType[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (stepId: BookingDisplayStepType) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((stepId: BookingDisplayStepType) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingFlowSuccess.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    successMessage: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingGuestChips.vue.d.ts

@@ -0,0 +1,11 @@
+import { BookingGuestOptionType } from '../../../../features/guest-auth/api/guest-auth.dto';
+type __VLS_Props = {
+    guestOptions: BookingGuestOptionType[];
+    selectedGuestIds: string[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "toggle-guest": (guestId: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onToggle-guest"?: ((guestId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingGuestsStep.vue.d.ts

@@ -0,0 +1,15 @@
+import { BookingGuestsStepPropsType } from '../../../../features/booking-flow/components/booking-flow.props';
+declare const _default: import('vue').DefineComponent<BookingGuestsStepPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: () => any;
+    "toggle-price-variant": (variantId: string) => any;
+    "toggle-guest": (guestId: string) => any;
+    "update:comment": (value: string) => any;
+    "update:numberOfAdditionalParticipants": (count: number) => any;
+}, string, import('vue').PublicProps, Readonly<BookingGuestsStepPropsType> & Readonly<{
+    onSubmit?: (() => any) | undefined;
+    "onToggle-price-variant"?: ((variantId: string) => any) | undefined;
+    "onToggle-guest"?: ((guestId: string) => any) | undefined;
+    "onUpdate:comment"?: ((value: string) => any) | undefined;
+    "onUpdate:numberOfAdditionalParticipants"?: ((count: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingParticipantCounter.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    disabled?: boolean;
+    heading: string;
+    hint: string;
+    isIncrementDisabled: boolean;
+    value: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:value": (count: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((count: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/features/booking-flow/components/BookingTimeSection.vue.d.ts

@@ -0,0 +1,24 @@
+import { BookitoEventType, BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type __VLS_Props = {
+    availableDates: string[];
+    canContinue: boolean;
+    event: BookitoEventType;
+    isSubmitting?: boolean;
+    isTimeSlotsLoading?: boolean;
+    language: string;
+    requiresTimeStep: boolean;
+    selectedDate: string;
+    selectedTimeSlotStart: string;
+    timeSlots: BookitoTimeSlotType[];
+    timezone?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    next: () => any;
+    "update:selectedDate": (value: string) => any;
+    "update:selectedTimeSlotStart": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNext?: (() => any) | undefined;
+    "onUpdate:selectedDate"?: ((value: string) => any) | undefined;
+    "onUpdate:selectedTimeSlotStart"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/src/features/booking-flow/components/booking-flow.props.d.ts

@@ -0,0 +1,31 @@
+import { BookingSubmitLabelKeyType } from '../../../../features/booking-flow/lib/booking-payload.helpers';
+import { BookitoPriceVariantType, BookitoEventType } from '../../../../features/event-feed/model/widget.types';
+import { BookingGuestOptionType } from '../../../../features/guest-auth/api/guest-auth.dto';
+export type BookingFlowPanelPropsType = {
+    authId: string;
+    availableDates?: string[];
+    currency?: string;
+    event: BookitoEventType;
+    initialDate: string;
+    language: string;
+    timezone?: string;
+};
+export type BookingGuestsStepPropsType = {
+    basePrice?: number | null;
+    comment: string;
+    currency: string;
+    formError: string | null;
+    guestOptions: BookingGuestOptionType[];
+    hasExternalMainBooker?: boolean;
+    showRoomGuests?: boolean;
+    isCustomOverCapacity?: boolean;
+    isSpaEvent?: boolean;
+    isSubmitting?: boolean;
+    language: string;
+    maxAdditional: number | undefined;
+    numberOfAdditionalParticipants: number;
+    priceVariants: BookitoPriceVariantType[];
+    selectedGuestIds: string[];
+    selectedPriceVariantIds: string[];
+    submitLabelKey: BookingSubmitLabelKeyType;
+};

package/dist/src/features/booking-flow/composables/create-booking-flow-api.d.ts

@@ -0,0 +1,70 @@
+import { ComputedRef, Ref } from 'vue';
+import { useBookingFlowActions } from '../../../../features/booking-flow/composables/useBookingFlowActions';
+import { BookingSubmitLabelKeyType } from '../../../../features/booking-flow/lib/booking-payload.helpers';
+import { BookingDisplayStepEntryType, BookingDisplayStepType } from '../../../../features/booking-flow/model/booking-display-step.types';
+import { BookingFormStateType, BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+import { ResolveBookingWaitlistResultType } from '../../../../features/booking-flow/lib/resolve-booking-waitlist';
+import { BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type ActionsType = ReturnType<typeof useBookingFlowActions>;
+type ContextType = {
+    actions: ActionsType;
+    activeDisplayStep: ComputedRef<BookingDisplayStepType>;
+    availableDates: ComputedRef<string[]>;
+    currency: ComputedRef<string>;
+    displaySteps: ComputedRef<BookingDisplayStepEntryType[]>;
+    form: BookingFormStateType;
+    hasPms: ComputedRef<boolean>;
+    isCustomOverCapacity: ComputedRef<boolean>;
+    isSubmitting: Ref<boolean>;
+    isSuccess: Ref<boolean>;
+    isTimeSlotsLoading: Ref<boolean>;
+    maxParticipants: ComputedRef<number>;
+    requiresTimeStep: ComputedRef<boolean>;
+    step: Ref<BookingStepType>;
+    submitError: Ref<string | null>;
+    submitLabelKey: ComputedRef<BookingSubmitLabelKeyType>;
+    successMessage: Ref<string>;
+    timeSlots: Ref<BookitoTimeSlotType[]>;
+    waitlist: ComputedRef<ResolveBookingWaitlistResultType>;
+};
+export declare function createBookingFlowApi(context: ContextType): {
+    activeDisplayStep: ComputedRef<BookingDisplayStepType>;
+    availableDates: ComputedRef<string[]>;
+    availableGuests: ComputedRef<import('../../guest-auth/api/guest-auth.dto').BookingGuestOptionType[]>;
+    canContinueDate: ComputedRef<boolean>;
+    canContinueTime: ComputedRef<boolean>;
+    canContinueDetails: ComputedRef<boolean>;
+    canContinueTimeSection: ComputedRef<boolean>;
+    canGoToDisplayStep: (target: BookingDisplayStepType) => boolean;
+    canGoToStep: (target: BookingStepType) => boolean;
+    confirmBooking: () => Promise<void>;
+    continueFromDetails: () => Promise<void>;
+    continueFromTimeSection: () => void;
+    currency: ComputedRef<string>;
+    displaySteps: ComputedRef<BookingDisplayStepEntryType[]>;
+    form: BookingFormStateType;
+    goToDisplayStep: (target: BookingDisplayStepType) => void;
+    goToStep: (target: BookingStepType) => void;
+    goToTimeStep: () => Promise<void> | undefined;
+    hasPms: ComputedRef<boolean>;
+    isCustomOverCapacity: ComputedRef<boolean>;
+    isDisplayStepComplete: (target: BookingDisplayStepType) => boolean;
+    isStepComplete: (stepId: BookingStepType) => boolean;
+    isSubmitting: Ref<boolean, boolean>;
+    isSuccess: Ref<boolean, boolean>;
+    isTimeSlotsLoading: Ref<boolean, boolean>;
+    maxParticipants: ComputedRef<number>;
+    onDateOfBirthInput: (value: string) => void;
+    requiresTimeStep: ComputedRef<boolean>;
+    setExtraParticipantCount: (count: number) => void;
+    step: Ref<BookingStepType, BookingStepType>;
+    submitError: Ref<string | null, string | null>;
+    submitLabelKey: ComputedRef<BookingSubmitLabelKeyType>;
+    successMessage: Ref<string, string>;
+    timeSlots: Ref<BookitoTimeSlotType[], BookitoTimeSlotType[]>;
+    toggleExtra: (id: string) => void;
+    toggleGuestId: (id: string) => void;
+    hasExternalMainBooker: ComputedRef<boolean>;
+    waitlist: ComputedRef<ResolveBookingWaitlistResultType>;
+};
+export {};

package/dist/src/features/booking-flow/composables/useBookingFlow.d.ts

@@ -0,0 +1,52 @@
+import { BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+import { BookitoEventType } from '../../../../features/event-feed/model/widget.types';
+type OptionsType = {
+    authId: string;
+    availableDates?: string[];
+    currency?: string;
+    event: BookitoEventType;
+    initialDate: string;
+    language: string;
+    onCompleted: () => void;
+};
+export declare function useBookingFlow(options: OptionsType): {
+    activeDisplayStep: import('vue').ComputedRef<import('../model/booking-display-step.types').BookingDisplayStepType>;
+    availableDates: import('vue').ComputedRef<string[]>;
+    availableGuests: import('vue').ComputedRef<import('../../guest-auth/api/guest-auth.dto').BookingGuestOptionType[]>;
+    canContinueDate: import('vue').ComputedRef<boolean>;
+    canContinueTime: import('vue').ComputedRef<boolean>;
+    canContinueDetails: import('vue').ComputedRef<boolean>;
+    canContinueTimeSection: import('vue').ComputedRef<boolean>;
+    canGoToDisplayStep: (target: import('../model/booking-display-step.types').BookingDisplayStepType) => boolean;
+    canGoToStep: (target: BookingStepType) => boolean;
+    confirmBooking: () => Promise<void>;
+    continueFromDetails: () => Promise<void>;
+    continueFromTimeSection: () => void;
+    currency: import('vue').ComputedRef<string>;
+    displaySteps: import('vue').ComputedRef<import('../model/booking-display-step.types').BookingDisplayStepEntryType[]>;
+    form: import('../../../../features/booking-flow/model/booking-form.types').BookingFormStateType;
+    goToDisplayStep: (target: import('../model/booking-display-step.types').BookingDisplayStepType) => void;
+    goToStep: (target: BookingStepType) => void;
+    goToTimeStep: () => Promise<void> | undefined;
+    hasPms: import('vue').ComputedRef<boolean>;
+    isCustomOverCapacity: import('vue').ComputedRef<boolean>;
+    isDisplayStepComplete: (target: import('../model/booking-display-step.types').BookingDisplayStepType) => boolean;
+    isStepComplete: (stepId: BookingStepType) => boolean;
+    isSubmitting: import('vue').Ref<boolean, boolean>;
+    isSuccess: import('vue').Ref<boolean, boolean>;
+    isTimeSlotsLoading: import('vue').Ref<boolean, boolean>;
+    maxParticipants: import('vue').ComputedRef<number>;
+    onDateOfBirthInput: (value: string) => void;
+    requiresTimeStep: import('vue').ComputedRef<boolean>;
+    setExtraParticipantCount: (count: number) => void;
+    step: import('vue').Ref<BookingStepType, BookingStepType>;
+    submitError: import('vue').Ref<string | null, string | null>;
+    submitLabelKey: import('vue').ComputedRef<import('../../../../features/booking-flow/lib/booking-payload.helpers').BookingSubmitLabelKeyType>;
+    successMessage: import('vue').Ref<string, string>;
+    timeSlots: import('vue').Ref<import('../../../../features/event-feed/model/widget.types').BookitoTimeSlotType[], import('../../../../features/event-feed/model/widget.types').BookitoTimeSlotType[]>;
+    toggleExtra: (id: string) => void;
+    toggleGuestId: (id: string) => void;
+    hasExternalMainBooker: import('vue').ComputedRef<boolean>;
+    waitlist: import('vue').ComputedRef<import('../lib/resolve-booking-waitlist').ResolveBookingWaitlistResultType>;
+};
+export {};

package/dist/src/features/booking-flow/composables/useBookingFlowActions.d.ts

@@ -0,0 +1,13 @@
+import { BookingDisplayStepType } from '../../../../features/booking-flow/model/booking-display-step.types';
+import { BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+import { BookingFlowActionsOptionsType } from './useBookingFlowActions.types';
+export declare function useBookingFlowActions(options: BookingFlowActionsOptionsType): {
+    confirmBooking: () => Promise<void>;
+    continueFromDetails: () => Promise<void>;
+    continueFromTimeSection: () => void;
+    goToTimeStep: () => Promise<void> | undefined;
+    goToDisplayStep: (target: BookingDisplayStepType, internalStep: BookingStepType | null) => void;
+    goToStep: (target: BookingStepType) => void;
+    onDateOfBirthInput: (value: string) => void;
+    setExtraParticipantCount: (count: number) => void;
+};

package/dist/src/features/booking-flow/composables/useBookingFlowActions.types.d.ts

@@ -0,0 +1,31 @@
+import { ComputedRef, Ref } from 'vue';
+import { CreateBookitoBookingRequestType } from '../../../../features/booking-flow/api/bookito-booking.dto';
+import { BookingFormStateType, BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+import { ResolveBookingWaitlistResultType } from '../../../../features/booking-flow/lib/resolve-booking-waitlist';
+import { BookitoEventType, BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+import { GuestLoginRequestType, GuestLoginResponseType } from '../../../../features/guest-auth/api/guest-auth.dto';
+export type CreateBookingMutationType = {
+    mutateAsync: (payload: CreateBookitoBookingRequestType) => Promise<unknown>;
+};
+export type GuestLoginMutationType = {
+    mutateAsync: (payload: GuestLoginRequestType) => Promise<GuestLoginResponseType>;
+};
+export type BookingFlowActionsOptionsType = {
+    authId: string;
+    event: BookitoEventType;
+    form: BookingFormStateType;
+    hasCompletedConfirmStep: Ref<boolean>;
+    hasPms: ComputedRef<boolean>;
+    isSubmitting: Ref<boolean>;
+    isSuccess: Ref<boolean>;
+    language: string;
+    onCompleted: () => void;
+    requiresTimeStep: ComputedRef<boolean>;
+    step: Ref<BookingStepType>;
+    submitError: Ref<string | null>;
+    successMessage: Ref<string>;
+    timeSlots: Ref<BookitoTimeSlotType[]>;
+    waitlist: ComputedRef<ResolveBookingWaitlistResultType>;
+    createBookingMutation: CreateBookingMutationType;
+    guestLoginMutation: GuestLoginMutationType;
+};

package/dist/src/features/booking-flow/composables/useBookingFlowFormSync.d.ts

@@ -0,0 +1,12 @@
+import { ComputedRef, Ref } from 'vue';
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+type OptionsType = {
+    form: BookingFormStateType;
+    hasCompletedConfirmStep: Ref<boolean>;
+    hasPms: ComputedRef<boolean>;
+    waitlist: ComputedRef<{
+        maxNumberOfAdditionalParticipants?: number | null;
+    }>;
+};
+export declare function useBookingFlowFormSync(options: OptionsType): void;
+export {};

package/dist/src/features/booking-flow/composables/useBookingFlowWaitlist.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+import { BookitoEventType, BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type OptionsType = {
+    event: BookitoEventType;
+    form: BookingFormStateType;
+    initialDate: string;
+    requiresTimeStep: Ref<boolean>;
+    timeSlots: Ref<BookitoTimeSlotType[]>;
+};
+export declare function useBookingFlowWaitlist(options: OptionsType): {
+    capacityTimeSlot: import('vue').ComputedRef<BookitoTimeSlotType | null>;
+    maxParticipants: import('vue').ComputedRef<number>;
+    selectedTimeSlot: import('vue').ComputedRef<BookitoTimeSlotType | null>;
+    waitlist: import('vue').ComputedRef<import('../../../../features/booking-flow/lib/resolve-booking-waitlist').ResolveBookingWaitlistResultType>;
+};
+export {};

package/dist/src/features/booking-flow/composables/useBookingGuestsStepLabels.d.ts

@@ -0,0 +1,26 @@
+import { BookingSubmitLabelKeyType } from '../../../../features/booking-flow/lib/booking-payload.helpers';
+import { BookitoPriceVariantType } from '../../../../features/event-feed/model/widget.types';
+import { SupportedLanguageType } from '../../../../shared/config/languages';
+type BookingGuestsStepLabelsParamsType = {
+    basePrice: number | null;
+    currency: string;
+    /** Custom timeslots over capacity — waitlist not allowed; CTA stays disabled (legacy). */
+    isCustomOverCapacity: boolean;
+    hasExternalMainBooker: boolean;
+    language: SupportedLanguageType;
+    maxAdditional: number | undefined;
+    numberOfAdditionalParticipants: number;
+    priceVariants: BookitoPriceVariantType[];
+    selectedGuestIds: string[];
+    selectedPriceVariantIds: string[];
+    submitLabelKey: BookingSubmitLabelKeyType;
+};
+export declare function useBookingGuestsStepLabels(getParams: () => BookingGuestsStepLabelsParamsType): {
+    bookingForLabel: import('vue').ComputedRef<string>;
+    isAdditionalIncrementDisabled: import('vue').ComputedRef<boolean>;
+    isSubmitDisabled: import('vue').ComputedRef<boolean>;
+    participantsHeading: import('vue').ComputedRef<string>;
+    submitLabel: import('vue').ComputedRef<string>;
+    totalParticipants: import('vue').ComputedRef<number>;
+};
+export {};

package/dist/src/features/booking-flow/composables/useBookingTimeSectionState.d.ts

@@ -0,0 +1,19 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BookitoEventType, BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type OptionsType = {
+    availableDates: string[];
+    event: BookitoEventType;
+    language: string;
+    selectedDate: MaybeRefOrGetter<string>;
+    timezone?: string;
+    onSelectedDateChange: (value: string) => void;
+    onSelectedTimeSlotChange: (value: string) => void;
+};
+export declare function useBookingTimeSectionState(options: OptionsType): {
+    formatSlotLabel: (slot: BookitoTimeSlotType) => string;
+    hasAvailableDates: import('vue').ComputedRef<boolean>;
+    intlLanguage: import('vue').ComputedRef<"en" | "de" | "fr" | "it" | "pl">;
+    onTimeSlotChange: (event: Event) => void;
+    selectedDateKey: import('vue').WritableComputedRef<"" | `${number}-${string}-${string}`, "" | `${number}-${string}-${string}`>;
+};
+export {};

package/dist/src/features/booking-flow/composables/useBookingTimeSlots.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type TimeSlotsFormType = {
+    bookedForDate: string;
+    selectedTimeSlotStart: string;
+};
+export declare function useBookingTimeSlots(options: {
+    authId: string;
+    enabled: Ref<boolean>;
+    eventId: string;
+    form: TimeSlotsFormType;
+    initialDate: string;
+    requiresTimeStep: Ref<boolean>;
+}): {
+    isTimeSlotsLoading: import('vue').ComputedRef<boolean>;
+    timeSlots: import('vue').ComputedRef<BookitoTimeSlotType[]>;
+};
+export {};

package/dist/src/features/booking-flow/lib/booking-calendar-bounds.d.ts

@@ -0,0 +1,9 @@
+import { DateValue } from 'reka-ui';
+import { CalendarDateKeyType } from '../../../../shared/calendar/calendar-date.types';
+export declare function normalizeBookingCalendarDateKey(value: string): CalendarDateKeyType | null;
+export declare function resolveBookingCalendarBounds(availableDates: string[]): {
+    availableDateKeys: `${number}-${string}-${string}`[];
+    maxValue: `${number}-${string}-${string}` | null;
+    minValue: `${number}-${string}-${string}` | null;
+};
+export declare function isBookingCalendarDateUnavailable(date: DateValue, availableDateKeys: ReadonlySet<CalendarDateKeyType>): boolean;

package/dist/src/features/booking-flow/lib/booking-details-flow.helpers.d.ts

@@ -0,0 +1,11 @@
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+export type BookingDetailsFlowSignatureType = {
+    flow: 'extended';
+} | {
+    flow: 'pms_login';
+    bookingReference: string;
+    dateOfBirth: string;
+    roomNumber: string;
+};
+export declare function resolveBookingDetailsFlowSignature(hasPms: boolean, form: BookingFormStateType): BookingDetailsFlowSignatureType;
+export declare function areBookingDetailsFlowSignaturesEqual(previous: BookingDetailsFlowSignatureType | undefined, next: BookingDetailsFlowSignatureType): boolean;

package/dist/src/features/booking-flow/lib/booking-details.helpers.d.ts

@@ -0,0 +1,26 @@
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+export type BookingDetailsFormModeType = {
+    showBookingReferenceField: boolean;
+    showDateOfBirth: boolean;
+    showExtendedForm: boolean;
+    showLanguage: boolean;
+    showRoomField: boolean;
+};
+/**
+ * PMS hotels (legacy BookitoGuestForm):
+ * - Room/ref row (mutually exclusive) always visible.
+ * - Room OR ref filled → date of birth (hotel guest login path).
+ * - Neither filled → name, email, phone (external guest on PMS property).
+ *
+ * Non-PMS hotels:
+ * - Always extended form: room (optional), booking ref (optional), name, email, phone, language.
+ * - No date-of-birth swap (not in Web Widget doc for this case).
+ */
+export declare function resolveBookingDetailsFormMode(hasPms: boolean, form: BookingFormStateType): BookingDetailsFormModeType;
+export declare function isValidGuestEmail(value: string): boolean;
+/** Fields marked “(Optional)” in copy are not required; all others are required when visible. */
+export declare function canContinueFromDetails(hasPms: boolean, form: BookingFormStateType): boolean;
+export declare function isDetailsStepValid(hasPms: boolean, form: BookingFormStateType): boolean;
+export declare function shouldAuthenticateGuestOnDetailsSubmit(hasPms: boolean, form: BookingFormStateType): boolean;
+/** Reservation guest chips apply only on the PMS hotel-guest path (room or booking ref + DOB). */
+export declare function shouldShowRoomGuestSelection(hasPms: boolean, form: BookingFormStateType): boolean;

package/dist/src/features/booking-flow/lib/booking-external-participant.helpers.d.ts

@@ -0,0 +1,10 @@
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+export declare function buildExternalParticipant(form: BookingFormStateType): {
+    communicationLanguage: string | undefined;
+    email: string | undefined;
+    isMainBooker: boolean;
+    isExternal: boolean;
+    name: string | null;
+    phoneNr: string | undefined;
+    roomNr: string | undefined;
+};

package/dist/src/features/booking-flow/lib/booking-flow-stepper.helpers.d.ts

@@ -0,0 +1,17 @@
+import { BookingDisplayStepEntryType, BookingDisplayStepType } from '../../../../features/booking-flow/model/booking-display-step.types';
+import { BookingFormStateType, BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+export declare function getBookingFlowStepperStepClasses(options: {
+    isActive: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+}): string;
+export declare function buildDisplayBookingStepEntries(labels: {
+    confirm: string;
+    details: string;
+    time: string;
+}): BookingDisplayStepEntryType[];
+export declare function isTimePhaseComplete(form: BookingFormStateType, requiresTimeStep: boolean): boolean;
+export declare function resolveActiveDisplayStep(internalStep: BookingStepType): BookingDisplayStepType;
+export declare function isDisplayStepComplete(displayStep: BookingDisplayStepType, internalStep: BookingStepType, form: BookingFormStateType, requiresTimeStep: boolean, isSuccess: boolean): boolean;
+export declare function canGoToDisplayStep(targetStep: BookingDisplayStepType, internalStep: BookingStepType, form: BookingFormStateType, requiresTimeStep: boolean, hasPms: boolean): boolean;
+export declare function resolveInternalStepFromDisplayStep(displayStep: BookingDisplayStepType): BookingStepType | null;

package/dist/src/features/booking-flow/lib/booking-flow.actions.d.ts

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+import { CreateBookitoBookingRequestType } from '../../../../features/booking-flow/api/bookito-booking.dto';
+import { BookingFormStateType, BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+import { BookingGuestOptionType, GuestLoginRequestType, GuestLoginResponseType } from '../../../../features/guest-auth/api/guest-auth.dto';
+type GuestLoginMutationType = {
+    mutateAsync: (payload: GuestLoginRequestType) => Promise<GuestLoginResponseType>;
+};
+type CreateBookingMutationType = {
+    mutateAsync: (payload: CreateBookitoBookingRequestType) => Promise<unknown>;
+};
+export declare function navigateToBookingStep(targetStep: BookingStepType, currentStep: Ref<BookingStepType>, form: BookingFormStateType, requiresTimeStep?: boolean): void;
+export declare function authenticateAndContinueBooking(options: {
+    authId: string;
+    form: BookingFormStateType;
+    guestLoginMutation: GuestLoginMutationType;
+    isSubmitting: Ref<boolean>;
+    loginErrorMessage: string;
+    nextStep: BookingStepType;
+    onGuestsResolved?: (guests: BookingGuestOptionType[]) => void;
+    resolveFixedTimeSlot?: () => string;
+    step: Ref<BookingStepType>;
+    submitError: Ref<string | null>;
+}): Promise<void>;
+export declare function submitBookingAndShowSuccess(options: {
+    bookingErrorMessage: string;
+    createBookingMutation: CreateBookingMutationType;
+    isSubmitting: Ref<boolean>;
+    isSuccess: Ref<boolean>;
+    onCompleted: () => void;
+    payload: CreateBookitoBookingRequestType;
+    successDelayMs: number;
+    submitError: Ref<string | null>;
+}): Promise<void>;
+export {};

package/dist/src/features/booking-flow/lib/booking-flow.helpers.d.ts

@@ -0,0 +1,32 @@
+import { BookingFormStateType, BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+import { BookitoEventType } from '../../../../features/event-feed/model/widget.types';
+export declare function createBookingForm(initialDate: string): BookingFormStateType;
+export declare function updateDateOfBirth(form: BookingFormStateType, value: string, language: string): void;
+export declare function canContinueFromDate(form: BookingFormStateType): boolean;
+export declare function canContinueFromTimeSection(form: BookingFormStateType, requiresTimeStep: boolean): boolean;
+export declare function canContinueFromTime(form: BookingFormStateType): boolean;
+export declare function canContinueFromDetailsStep(hasPms: boolean, form: BookingFormStateType): boolean;
+export { isBookingStepComplete } from './booking-step-completion.helpers';
+export declare function canGoToBookingStep(targetStep: BookingStepType, currentStep: BookingStepType, form: BookingFormStateType, requiresTimeStep?: boolean, hasPms?: boolean): boolean;
+export declare function toggleIdInList(list: string[], id: string): string[];
+export declare function clampParticipantCount(value: number, max: number): number;
+export declare function resolveExtraParticipantCount(value: number, max: number | null | undefined): number;
+export declare function resolveGuestLoginDateOfBirth(maskedValue: string): string | null;
+export declare function eventRequiresCustomTimeStep(event: BookitoEventType): boolean;
+export declare function resolveBookingAvailableDates(availableDates: string[] | undefined, initialDate: string): string[];
+export declare function resolveHasExternalMainBooker(form: BookingFormStateType): boolean;
+export declare function buildBookingStepEntries(labels: {
+    date: string;
+    guests: string;
+    time: string;
+}, requiresTimeStep: boolean): ({
+    id: "date";
+    label: string;
+} | {
+    id: "time";
+    label: string;
+} | {
+    id: "guests";
+    label: string;
+})[];
+export declare const BOOKING_SUCCESS_DISPLAY_MS = 2000;