bookito-widget 0.43.1 → 1.0.0-beta.2

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

@@ -0,0 +1,4 @@
+import { CreateBookitoBookingRequestType } from '../../../../features/booking-flow/api/bookito-booking.dto';
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+import { BookingGuestOptionType } from '../../../../features/guest-auth/api/guest-auth.dto';
+export declare function resolveBookingParticipants(form: BookingFormStateType, selectedGuests: BookingGuestOptionType[]): CreateBookitoBookingRequestType['participants'];

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

@@ -0,0 +1,14 @@
+import { BookitoEventType } from '../../../../features/event-feed/model/widget.types';
+export type BookingSubmitLabelKeyType = 'confirmBooking' | 'joinWaitlist' | 'sendRequest';
+export declare function resolveBookingSuccessMessageKey(options: {
+    bookability: BookitoEventType['bookability'];
+    canBePutOnWaitingList: boolean;
+}): "widget.bookingSuccessWaitlist" | "widget.bookingSuccessRequest" | "widget.bookingSuccess";
+export declare function resolveBookingSubmitLabelKey(options: {
+    bookability: BookitoEventType['bookability'];
+    canBePutOnWaitingList: boolean;
+}): BookingSubmitLabelKeyType;
+export declare function resolveBookingConfirmLabelKey(options: {
+    bookability: BookitoEventType['bookability'];
+    canBePutOnWaitingList: boolean;
+}): "widget.confirmBooking" | "widget.joinWaitlist" | "widget.sendRequest";

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

@@ -0,0 +1,11 @@
+import { BookitoEventType, BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+import { CreateBookitoBookingRequestType } from '../../../../features/booking-flow/api/bookito-booking.dto';
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+export declare function formatMoneyAmount(price: number | null, language: string, freeLabel: string, currency?: string): string;
+export declare function formatExtraPrice(price: number | null, language: string, freeLabel: string, currency?: string): string;
+export declare function buildCreateBookingPayload(eventId: string, form: BookingFormStateType, timeSlots?: BookitoTimeSlotType[]): CreateBookitoBookingRequestType;
+export declare function resolveBookingSuccessMessageKey(options: {
+    bookability: BookitoEventType['bookability'];
+    canBePutOnWaitingList: boolean;
+}): "widget.bookingSuccessWaitlist" | "widget.bookingSuccessRequest" | "widget.bookingSuccess";
+export { type BookingSubmitLabelKeyType, resolveBookingConfirmLabelKey, resolveBookingSubmitLabelKey, } from './booking-payload-label.helpers';

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

@@ -0,0 +1,2 @@
+import { BookingFormStateType, BookingStepType } from '../../../../features/booking-flow/model/booking-form.types';
+export declare function isBookingStepComplete(stepId: BookingStepType, currentStep: BookingStepType, form: BookingFormStateType, requiresTimeStep?: boolean, hasPms?: boolean): boolean;

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

@@ -0,0 +1,8 @@
+import { BookitoEventType, BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+export declare function resolveSelectedTimeSlot(selectedTimeSlotStart: string, timeSlots: BookitoTimeSlotType[]): BookitoTimeSlotType | null;
+/**
+ * Fixed-time (non-custom) events: synthesize a capacity slot for waitlist math
+ * (guest-app `resolveAutoSelectedTimeSlot`).
+ */
+export declare function resolveCapacityTimeSlot(event: BookitoEventType, selectedTimeSlot: BookitoTimeSlotType | null, fixedStartIso: string): BookitoTimeSlotType | null;
+export declare function resolveFixedOccurrenceStartIso(event: BookitoEventType, dateIso: string): string;

package/dist/src/features/booking-flow/lib/filter-phone-dial-codes.d.ts

@@ -0,0 +1,2 @@
+import { PhoneDialCodeCountryType } from './phone-dial-codes';
+export declare function filterPhoneDialCodeCountries(countries: PhoneDialCodeCountryType[], query: string): PhoneDialCodeCountryType[];

package/dist/src/features/booking-flow/lib/format-booking-time-slot-label.d.ts

@@ -0,0 +1,13 @@
+import { SupportedLanguageType } from '../../../../shared/config/languages';
+import { BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type FormatBookingTimeSlotLabelParamsType = {
+    freeSlotsLabel: (count: number) => string;
+    language: SupportedLanguageType;
+    maxParticipants?: number | null;
+    slot: BookitoTimeSlotType;
+    timeBlockDurationMs?: number | null;
+    timezone: string;
+};
+export declare function resolveTimeSlotFreeCount(slot: BookitoTimeSlotType, maxParticipants?: number | null): number | null;
+export declare function formatBookingTimeSlotLabel({ freeSlotsLabel, language, maxParticipants, slot, timeBlockDurationMs, timezone, }: FormatBookingTimeSlotLabelParamsType): string;
+export {};

package/dist/src/features/booking-flow/lib/phone-dial-code-countries.data.d.ts

@@ -0,0 +1,2 @@
+import { PhoneDialCodeCountryType } from './phone-dial-codes';
+export declare const PHONE_DIAL_CODE_COUNTRIES_RAW: PhoneDialCodeCountryType[];

package/dist/src/features/booking-flow/lib/phone-dial-codes.d.ts

@@ -0,0 +1,6 @@
+export type PhoneDialCodeCountryType = {
+    name: string;
+    dial_code: string;
+    code: string;
+};
+export declare const PHONE_DIAL_CODE_COUNTRIES: PhoneDialCodeCountryType[];

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

@@ -0,0 +1 @@
+export declare function resetBookingGuestAuth(): void;

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

@@ -0,0 +1,2 @@
+import { BookingFormStateType } from '../../../../features/booking-flow/model/booking-form.types';
+export declare function resetBookingConfirmStep(form: BookingFormStateType): void;

package/dist/src/features/booking-flow/lib/resolve-booking-total-price.d.ts

@@ -0,0 +1,10 @@
+import { BookitoPriceVariantType } from '../../../../features/event-feed/model/widget.types';
+type ResolveBookingTotalPriceParamsType = {
+    basePrice: number | null;
+    numberOfAdditionalParticipants: number;
+    priceVariants: BookitoPriceVariantType[];
+    selectedGuestCount: number;
+    selectedPriceVariantIds: string[];
+};
+export declare function resolveBookingTotalPrice({ basePrice, numberOfAdditionalParticipants, priceVariants, selectedGuestCount, selectedPriceVariantIds, }: ResolveBookingTotalPriceParamsType): number;
+export {};

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

@@ -0,0 +1,19 @@
+import { BookitoTimeSlotType } from '../../../../features/event-feed/model/widget.types';
+type ResolveBookingWaitlistParamsType = {
+    isCustomTimeSlots: boolean;
+    maxParticipants: number | null | undefined;
+    numberOfAdditionalParticipants: number;
+    selectedParticipantCount: number;
+    selectedTimeSlot: BookitoTimeSlotType | null;
+    source: string | null | undefined;
+};
+export type ResolveBookingWaitlistResultType = {
+    availableSpots: number | undefined;
+    canBePutOnWaitingList: boolean;
+    maxNumberOfAdditionalParticipants: number | undefined;
+    resolvedMaxParticipants: number;
+    willBePutOnWaitingList: boolean;
+};
+/** Capacity / waitlist rules — same as guest-app `resolveBookingWaitlist`. */
+export declare function resolveBookingWaitlist({ isCustomTimeSlots, maxParticipants, numberOfAdditionalParticipants, selectedParticipantCount, selectedTimeSlot, source, }: ResolveBookingWaitlistParamsType): ResolveBookingWaitlistResultType;
+export {};

package/dist/src/features/booking-flow/model/booking-display-step.types.d.ts

@@ -0,0 +1,6 @@
+export type BookingDisplayStepType = 'time' | 'details' | 'confirm';
+export declare const BOOKING_DISPLAY_STEP_ORDER: BookingDisplayStepType[];
+export type BookingDisplayStepEntryType = {
+    id: BookingDisplayStepType;
+    label: string;
+};

package/dist/src/features/booking-flow/model/booking-form-date.helpers.d.ts

@@ -0,0 +1,10 @@
+export declare function isDateOfBirthComplete(value: string): boolean;
+export declare function getDateOfBirthSeparator(locale: string): "." | "/";
+export declare function formatDateOfBirthInput(rawValue: string, locale: string): string;
+export declare function toIsoDateOfBirth(maskedValue: string): string | null;
+export declare function splitDateOfBirthParts(maskedValue: string): {
+    day: string;
+    month: string;
+    year: string;
+};
+export declare function joinDateOfBirthParts(day: string, month: string, year: string, locale: string): string;

package/dist/src/features/booking-flow/model/booking-form-navigation.helpers.d.ts

@@ -0,0 +1,2 @@
+import { BookingFormStateType, BookingStepType } from './booking-form.types';
+export declare function canNavigateToBookingStep(targetStep: BookingStepType, currentStep: BookingStepType, form: BookingFormStateType, requiresTimeStep?: boolean): boolean;

package/dist/src/features/booking-flow/model/booking-form.types.d.ts

@@ -0,0 +1,27 @@
+import { BookingGuestOptionType } from '../../../../features/guest-auth/api/guest-auth.dto';
+export { formatDateOfBirthInput, getDateOfBirthSeparator, isDateOfBirthComplete, joinDateOfBirthParts, splitDateOfBirthParts, toIsoDateOfBirth, } from './booking-form-date.helpers';
+export type BookingStepType = 'date' | 'time' | 'details' | 'guests';
+export type BookingFormStateType = {
+    availableGuests: BookingGuestOptionType[];
+    bookedForDate: string;
+    bookingReference: string;
+    comment: string;
+    communicationLanguage: string;
+    dateOfBirth: string;
+    extraParticipantCount: number;
+    guestEmail: string;
+    guestName: string;
+    phoneDialCode: string;
+    phoneNumber: string;
+    roomNumber: string;
+    selectedExtraIds: string[];
+    selectedGuestIds: string[];
+    selectedTimeSlotStart: string;
+};
+export declare function createInitialBookingFormState(defaultDate?: string): BookingFormStateType;
+export declare function isDateStepValid(state: BookingFormStateType): boolean;
+export declare function isTimeStepValid(state: BookingFormStateType): boolean;
+export declare const BOOKING_STEP_ORDER: BookingStepType[];
+export declare function getBookingStepIndex(step: BookingStepType): number;
+export { canNavigateToBookingStep } from './booking-form-navigation.helpers';
+export declare function isCustomTimeBookability(timeBookability: string | null | undefined): timeBookability is "custom";

package/dist/src/features/bookito-settings/api/bookito-settings.client.d.ts

@@ -0,0 +1,2 @@
+import { BookitoSettingsType } from '../model/bookito-settings.types';
+export declare function fetchBookitoSettings(hotelId: string): Promise<BookitoSettingsType>;

package/dist/src/features/bookito-settings/api/bookito-settings.keys.d.ts

@@ -0,0 +1,4 @@
+export declare const bookitoSettingsQueryKeys: {
+    all: readonly ["bookito-settings"];
+    byHotel: (hotelId: string) => readonly ["bookito-settings", string];
+};

package/dist/src/features/bookito-settings/api/bookito-settings.queries.d.ts

@@ -0,0 +1,2 @@
+import { MaybeRefOrGetter } from 'vue';
+export declare function useBookitoSettingsQuery(hotelId: MaybeRefOrGetter<string>): import('@tanstack/vue-query').UseQueryReturnType<import('../model/bookito-settings.types').BookitoSettingsType, Error>;

package/dist/src/features/bookito-settings/model/bookito-settings.types.d.ts

@@ -0,0 +1,27 @@
+export declare const DEFAULT_DAYS_BOOKABLE_IN_ADVANCE = 14;
+export declare const DEFAULT_HOTEL_TIMEZONE = "Europe/Berlin";
+/** Doc B1: Date view baseline ≈ two weeks. */
+export declare const DATE_VIEW_MIN_DAYS = 14;
+/** Doc B1: List view baseline ≈ four weeks. */
+export declare const LIST_VIEW_MIN_DAYS = 28;
+export type BookitoSettingsType = {
+    currency: string;
+    daysBookableInAdvance: number;
+    daysViewableInAdvance: number | null;
+    timezone: string;
+    hasPms: boolean;
+};
+export declare function createDefaultBookitoSettings(): BookitoSettingsType;
+/**
+ * Feed window length from hotel bookito settings.
+ * Uses the configured value when set.
+ * Falls back to Date 14d / List 28d when bookito settings omit the field (null).
+ */
+export declare function resolveFeedViewableDays(viewMode: 'Date' | 'List', daysViewableInAdvance: number | null | undefined): number;
+export declare function addDaysToDate(date: Date, days: number): Date;
+/** Feed `fromDate` — hotel-local midnight. */
+export declare function computeViewableFromDateIso(timezone?: string, referenceDate?: Date): string;
+/** Feed `toDate` — hotel-local midnight + viewable days (no browser timezone offset). */
+export declare function computeViewableToDateIso(daysViewableInAdvance: number, fromDateIso: string, timezone?: string): string;
+/** Modal/detail `toDate` — matches old BookitoEventModal (`now + daysBookable`). */
+export declare function computeBookableToDateIso(daysBookableInAdvance: number, fromDate?: Date): string;

package/dist/src/features/event-feed/api/bookito-event-category.client.d.ts

@@ -0,0 +1,4 @@
+import { ListBookitoEventCategoriesResponseType } from './bookito-event-category.dto';
+type BookitoQueryParametersType = Record<string, string | number | boolean | null | undefined>;
+export declare function listBookitoEventCategories(params: BookitoQueryParametersType): Promise<ListBookitoEventCategoriesResponseType>;
+export {};

package/dist/src/features/event-feed/api/bookito-event-category.dto.d.ts

@@ -0,0 +1,11 @@
+import { FederationSuccessResponseType } from '../../../../shared/api/federation-client';
+import { BookitoLocalizedTextDtoType } from './bookito-event.dto';
+export type BookitoEventCategoryDtoType = {
+    displayName?: BookitoLocalizedTextDtoType;
+    id?: string | null;
+    name?: BookitoLocalizedTextDtoType;
+    title?: BookitoLocalizedTextDtoType;
+};
+export type ListBookitoEventCategoriesResponseType = FederationSuccessResponseType & {
+    eventCategories: BookitoEventCategoryDtoType[];
+};

package/dist/src/features/event-feed/api/bookito-event-category.queries.d.ts

@@ -0,0 +1,9 @@
+import { MaybeRefOrGetter } from 'vue';
+type CategoryTitleParamsType = {
+    authId: string;
+    categoryId?: string;
+    enabled?: boolean;
+    language?: string;
+};
+export declare function useBookitoCategoryTitleQuery(params: MaybeRefOrGetter<CategoryTitleParamsType>): import('@tanstack/vue-query').UseQueryReturnType<string | null, Error>;
+export {};

package/dist/src/features/event-feed/api/bookito-event-modal-dates.helpers.d.ts

@@ -0,0 +1,6 @@
+import { mapBookitoEventDates } from './bookito-event.mapper';
+export declare function resolveModalAvailableDates(options: {
+    availableOnDates?: Array<string | null | undefined> | null;
+    datesMap: ReturnType<typeof mapBookitoEventDates>;
+    eventId: string;
+}): string[];

package/dist/src/features/event-feed/api/bookito-event.client.d.ts

@@ -0,0 +1,5 @@
+import { ListBookitoEventsResponseType, ListBookitoTimeSlotsResponseType } from './bookito-event.dto';
+type BookitoQueryParametersType = Record<string, string | number | boolean | null | undefined>;
+export declare function listBookitoEvents(params: BookitoQueryParametersType): Promise<ListBookitoEventsResponseType>;
+export declare function listBookitoAvailableTimeSlots(params: BookitoQueryParametersType): Promise<ListBookitoTimeSlotsResponseType>;
+export {};

package/dist/src/features/event-feed/api/bookito-event.dto.d.ts

@@ -0,0 +1,102 @@
+import { FederationSuccessResponseType } from '../../../../shared/api/federation-client';
+export type BookitoContentImageDtoType = {
+    formats?: Record<string, {
+        url?: string | null;
+    }> | null;
+    url?: string | null;
+};
+export type BookitoMultiLangValueDtoType = {
+    type?: 'multi_lang' | string | null;
+    values?: Record<string, string | null | undefined> | null;
+};
+export type BookitoLocalizedTextDtoType = string | BookitoMultiLangValueDtoType | null | undefined;
+export type BookitoPriceVariationDtoType = {
+    amount?: number | null;
+    currency?: string | null;
+};
+export type BookitoPriceVariantDtoType = {
+    description?: BookitoLocalizedTextDtoType;
+    id?: string | null;
+    name?: BookitoLocalizedTextDtoType;
+    /** Flat amount — some clients; staging federation uses `priceVariation` instead. */
+    price?: number | null;
+    priceVariation?: BookitoPriceVariationDtoType | null;
+};
+export type BookitoBookabilityDtoType = 'bookable_autonomously' | 'bookable_on_request' | 'not_bookable';
+export type BookitoOccurrenceDtoType = {
+    durationMs?: number | null;
+    endDateTime?: string | null;
+    startDateTime?: string | null;
+};
+export type BookitoMoneyDtoType = {
+    amount?: number | null;
+    currency?: string | null;
+};
+export type BookitoEventCancellationStatusDtoType = 'cancelled' | 'deleted';
+export type BookitoEventCancelledDateDtoType = {
+    date?: string | null;
+    reason?: BookitoLocalizedTextDtoType;
+    status?: BookitoEventCancellationStatusDtoType | null;
+    type?: string | null;
+};
+export type BookitoEventDtoType = {
+    bannerImg?: BookitoContentImageDtoType | null;
+    basePrice?: BookitoMoneyDtoType | null;
+    bookability?: BookitoBookabilityDtoType | null;
+    bookableUntilBeforeStartMs?: number | null;
+    cancellationStatus?: {
+        reason?: BookitoLocalizedTextDtoType;
+        status?: BookitoEventCancellationStatusDtoType | null;
+    } | null;
+    cancelledDates?: BookitoEventCancelledDateDtoType[] | null;
+    description?: BookitoLocalizedTextDtoType;
+    eventCategoryIds?: string[] | null;
+    id?: string | null;
+    imageUrl?: string | null;
+    isBookable?: boolean | null;
+    maxParticipants?: number | null;
+    name?: BookitoLocalizedTextDtoType;
+    occurrences?: BookitoOccurrenceDtoType[] | null;
+    priceVariants?: BookitoPriceVariantDtoType[] | null;
+    source?: 'manual' | 'spa_system' | null;
+    timeBookability?: string | null;
+    timeBookabilitySettings?: BookitoTimeBookabilitySettingsDtoType | null;
+    title?: BookitoLocalizedTextDtoType;
+};
+export type BookitoTimeBookabilitySettingsDtoType = {
+    bufferTimeAfterMs?: number | null;
+    bufferTimeBeforeMs?: number | null;
+    startTimeIncrementMs?: number | null;
+    timeBlockDurationMs?: number | null;
+};
+export type BookitoTimeSlotDtoType = {
+    employeeId?: string | null;
+    endDateTime?: string | null;
+    numOfAvailableParticipants?: number | null;
+    numOfConfirmedParticipants?: number | null;
+    startDateTime?: string | null;
+};
+export type BookitoResolvedOccurrenceDtoType = {
+    bookabilityReason?: 'cancelled' | 'full' | 'not_bookable' | 'past' | null;
+    durationMs?: number | null;
+    isAllDay?: boolean | null;
+    isBookable?: boolean | null;
+    isCancelled?: boolean | null;
+    startDateTime?: string | null;
+};
+export type BookitoEventDateEntryDtoType = {
+    events?: Array<{
+        id?: string | null;
+        occurrences?: BookitoResolvedOccurrenceDtoType[] | null;
+    }> | null;
+};
+export type ListBookitoEventsResponseType = FederationSuccessResponseType & {
+    availableOnDates?: string[] | null;
+    dates?: Record<string, BookitoEventDateEntryDtoType> | null;
+    events: BookitoEventDtoType[];
+    limit?: number;
+    skip?: number;
+};
+export type ListBookitoTimeSlotsResponseType = FederationSuccessResponseType & {
+    availableTimeSlots: BookitoTimeSlotDtoType[];
+};

package/dist/src/features/event-feed/api/bookito-event.keys.d.ts

@@ -0,0 +1,7 @@
+export declare const bookitoEventQueryKeys: {
+    all: readonly ["bookito-events"];
+    list: (params: Record<string, unknown>) => readonly ["bookito-events", "list", Record<string, unknown>];
+    byId: (params: Record<string, unknown>) => readonly ["bookito-events", "by-id", Record<string, unknown>];
+    timeSlots: (params: Record<string, unknown>) => readonly ["bookito-events", "timeslots", Record<string, unknown>];
+    categoryTitle: (params: Record<string, unknown>) => readonly ["bookito-events", "category-title", Record<string, unknown>];
+};

package/dist/src/features/event-feed/api/bookito-event.mapper-helpers.d.ts

@@ -0,0 +1,17 @@
+import { BookitoBookabilityType, BookitoDataSourceType, BookitoEventType, BookitoOccurrenceType, BookitoResolvedOccurrenceType, BookitoTimeBookabilitySettingsType } from '../model/widget.types';
+import { BookitoEventDtoType, BookitoOccurrenceDtoType, BookitoResolvedOccurrenceDtoType, BookitoTimeBookabilitySettingsDtoType } from './bookito-event.dto';
+export { mapPriceVariant } from './bookito-event.mapper-variant.helpers';
+export declare function mapCancellationStatus(dto?: BookitoEventDtoType['cancellationStatus']): BookitoEventType['cancellationStatus'];
+export declare function mapCancelledDates(items?: BookitoEventDtoType['cancelledDates']): BookitoEventType['cancelledDates'];
+export declare function resolveBookability(dto: BookitoEventDtoType): BookitoBookabilityType;
+export declare function resolveIsBookable(dto: BookitoEventDtoType, bookability: BookitoBookabilityType): boolean;
+export declare function resolveDataSource(value?: string | null): BookitoDataSourceType | null;
+export declare function mapTimeBookabilitySettings(dto?: BookitoTimeBookabilitySettingsDtoType | null): BookitoTimeBookabilitySettingsType | null;
+export declare function resolveEventName(dto: BookitoEventDtoType, language: string): string;
+export declare function mapBasePrice(dto: BookitoEventDtoType['basePrice']): {
+    amount: number;
+    currency: string | null;
+} | null;
+export declare function mapOccurrence(dto: BookitoOccurrenceDtoType): BookitoOccurrenceType | null;
+export declare function mapResolvedOccurrence(dto: BookitoResolvedOccurrenceDtoType): BookitoResolvedOccurrenceType | null;
+export { resolveImageUrl } from './bookito-event.mapper-image.helpers';

package/dist/src/features/event-feed/api/bookito-event.mapper-image.helpers.d.ts

@@ -0,0 +1,2 @@
+import { BookitoEventDtoType } from './bookito-event.dto';
+export declare function resolveImageUrl(dto: BookitoEventDtoType): string | null;

package/dist/src/features/event-feed/api/bookito-event.mapper-variant.helpers.d.ts

@@ -0,0 +1,3 @@
+import { BookitoPriceVariantType } from '../model/widget.types';
+import { BookitoPriceVariantDtoType } from './bookito-event.dto';
+export declare function mapPriceVariant(dto: BookitoPriceVariantDtoType, language: string): BookitoPriceVariantType | null;

package/dist/src/features/event-feed/api/bookito-event.mapper.d.ts

@@ -0,0 +1,6 @@
+import { BookitoEventType, BookitoTimeSlotType, BookitoEventDatesType } from '../model/widget.types';
+import { BookitoEventDtoType, BookitoTimeSlotDtoType, ListBookitoEventsResponseType } from './bookito-event.dto';
+export { resolveLocalizedText } from '../lib/resolve-localized-text';
+export declare function mapBookitoEvent(dto: BookitoEventDtoType, language?: string): BookitoEventType | null;
+export declare function mapBookitoEventDates(dates: ListBookitoEventsResponseType['dates']): BookitoEventDatesType;
+export declare function mapBookitoTimeSlot(dto: BookitoTimeSlotDtoType): BookitoTimeSlotType | null;

package/dist/src/features/event-feed/api/bookito-event.queries.d.ts

@@ -0,0 +1,24 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BookitoEventType, BookitoEventsListResultType } from '../model/widget.types';
+type ListEventsParamsType = {
+    authId: string;
+    categoryId?: string;
+    excludeNonBookable?: boolean;
+    fromDate?: string;
+    language?: string;
+    toDate?: string;
+};
+type EventByIdParamsType = {
+    authId: string;
+    eventId: string;
+    language?: string;
+    toDate?: string;
+};
+export type BookitoEventByIdResultType = {
+    availableDates: string[];
+    dates: BookitoEventsListResultType['dates'];
+    event: BookitoEventType;
+};
+export declare function useBookitoEventsQuery(params: MaybeRefOrGetter<ListEventsParamsType>, enabled?: MaybeRefOrGetter<boolean>): import('@tanstack/vue-query').UseQueryReturnType<BookitoEventsListResultType, Error>;
+export declare function useBookitoEventByIdQuery(params: MaybeRefOrGetter<EventByIdParamsType>, enabled?: MaybeRefOrGetter<boolean>): import('@tanstack/vue-query').UseQueryReturnType<BookitoEventByIdResultType | null, Error>;
+export { useBookitoTimeSlotsQuery } from './bookito-time-slots.queries';

package/dist/src/features/event-feed/api/bookito-time-slots.queries.d.ts

@@ -0,0 +1,9 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BookitoTimeSlotType } from '../model/widget.types';
+type ListTimeSlotsParamsType = {
+    authId: string;
+    eventId: string;
+    onDate: string;
+};
+export declare function useBookitoTimeSlotsQuery(params: MaybeRefOrGetter<ListTimeSlotsParamsType>, enabled?: MaybeRefOrGetter<boolean>): import('@tanstack/vue-query').UseQueryReturnType<BookitoTimeSlotType[], Error>;
+export {};

package/dist/src/features/event-feed/components/BookitoWidget.vue.d.ts

@@ -0,0 +1,5 @@
+import { BookitoWidgetPropsType } from '../../../../features/event-feed/model/widget.types';
+declare const _default: import('vue').DefineComponent<BookitoWidgetPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BookitoWidgetPropsType> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootElement: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/src/features/event-feed/components/EventFeed.vue.d.ts

@@ -0,0 +1,21 @@
+import { BookitoEventDatesType, BookitoEventFeedItemType, BookitoEventType, BookitoWidgetViewModeType } from '../model/widget.types';
+type __VLS_Props = {
+    currency?: string;
+    dates?: BookitoEventDatesType;
+    events: BookitoEventType[];
+    isError?: boolean;
+    isLoading?: boolean;
+    language: string;
+    timezone?: string;
+    viewMode: BookitoWidgetViewModeType;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: BookitoEventFeedItemType) => any;
+    retry: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((item: BookitoEventFeedItemType) => any) | undefined;
+    onRetry?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    scrollContainer: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/src/features/event-feed/components/EventFeedScrollControls.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    canScrollNext: boolean;
+    canScrollPrev: boolean;
+    hasOverflow: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    next: () => any;
+    prev: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onNext?: (() => any) | undefined;
+    onPrev?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/src/features/event-feed/components/ExperienceCard.vue.d.ts

@@ -0,0 +1,13 @@
+import { BookitoEventFeedItemType } from '../model/widget.types';
+type __VLS_Props = {
+    currency?: string;
+    item: BookitoEventFeedItemType;
+    dateLabel: string;
+    language?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: BookitoEventFeedItemType) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((item: BookitoEventFeedItemType) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;

package/dist/src/features/event-feed/components/PoweredByCarlito.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLAnchorElement>;
+export default _default;

package/dist/src/features/event-feed/composables/useBookitoWidgetTheme.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useBookitoWidgetTheme(authId: () => string, rootElement: Ref<HTMLElement | null>): void;

package/dist/src/features/event-feed/composables/useEventFeedScroll.d.ts

@@ -0,0 +1,8 @@
+import { ShallowRef } from 'vue';
+export declare function useEventFeedScroll(scrollContainerRef: Readonly<ShallowRef<HTMLElement | null>>): {
+    canScrollNext: import('vue').ComputedRef<boolean>;
+    canScrollPrev: import('vue').ComputedRef<boolean>;
+    hasOverflow: import('vue').ComputedRef<boolean>;
+    scrollNext: () => void;
+    scrollPrev: () => void;
+};

package/dist/src/features/event-feed/lib/event-feed-date.utils.d.ts

@@ -0,0 +1,15 @@
+import { BookitoOccurrenceType, BookitoResolvedOccurrenceType } from '../model/widget.types';
+type DateFormatOptionsType = {
+    locale?: string;
+    timezone?: string;
+};
+export declare function formatTimeframeLabel(startDateTime: string, endDateTime: string | null, locale?: string, timezone?: string): string;
+/** Parse `YYYY-MM-DD` as a local calendar day (avoids UTC midnight shift). */
+export declare function parseCalendarDate(dateIso: string): Date;
+export declare function formatDateLabel(dateIso: string, locale?: string, timezone?: string): string;
+export declare function formatLocalDateIso(date?: Date): string;
+/** Copy clock time from `timeSource` onto the calendar day of `onDate` (old applyTimeOfDate). */
+export declare function applyTimeOfDate(onDate: Date, timeSource: Date): Date;
+export declare function formatOccurrenceTimeframeOnDate(dateIso: string, occurrence: BookitoOccurrenceType | undefined, timezone?: string, locale?: string): string;
+export declare function formatResolvedOccurrenceTimeframe(occurrence: Pick<BookitoResolvedOccurrenceType, 'durationMs' | 'startDateTime'>, options?: DateFormatOptionsType): string;
+export {};

package/dist/src/features/event-feed/lib/event-feed-item.helpers.d.ts

@@ -0,0 +1,9 @@
+import { BookitoEventDatesType, BookitoEventFeedItemType, BookitoEventType, BookitoWidgetViewModeType } from '../model/widget.types';
+type BuildEventFeedItemsOptionsType = {
+    language?: string;
+    timezone?: string;
+};
+export declare function resolveEventAvailableDates(eventId: string, dates: BookitoEventDatesType): string[];
+export declare function buildEventFeedItems(events: BookitoEventType[], dates: BookitoEventDatesType, viewMode: BookitoWidgetViewModeType, options?: BuildEventFeedItemsOptionsType): BookitoEventFeedItemType[];
+export declare function buildSingleFeedItem(event: BookitoEventType, date: string, dates: BookitoEventDatesType, options?: BuildEventFeedItemsOptionsType): BookitoEventFeedItemType | null;
+export {};

package/dist/src/features/event-feed/lib/event-feed-occurrence.helpers.d.ts

@@ -0,0 +1,7 @@
+import { BookitoEventType, BookitoResolvedOccurrenceType } from '../model/widget.types';
+type FeedItemFormatOptionsType = {
+    language?: string;
+    timezone?: string;
+};
+export declare function formatFeedItemTimeframe(date: string, resolvedOccurrence: BookitoResolvedOccurrenceType | undefined, fallbackOccurrence: BookitoEventType['occurrences'][number] | undefined, options: FeedItemFormatOptionsType): string;
+export {};

package/dist/src/features/event-feed/lib/event-feed.utils.d.ts

@@ -0,0 +1,8 @@
+import { BookitoEventFeedItemType } from '../model/widget.types';
+export { applyTimeOfDate, formatDateLabel, formatLocalDateIso, formatOccurrenceTimeframeOnDate, formatResolvedOccurrenceTimeframe, formatTimeframeLabel, parseCalendarDate, } from './event-feed-date.utils';
+export { buildEventFeedItems, resolveEventAvailableDates } from './event-feed-item.helpers';
+export declare function formatEventPrice(amount: number, currency: string, language?: string): string;
+export declare function groupFeedItemsByDate(items: BookitoEventFeedItemType[]): {
+    date: string;
+    items: BookitoEventFeedItemType[];
+}[];

package/dist/src/features/event-feed/lib/resolve-localized-text.d.ts

@@ -0,0 +1,2 @@
+import { BookitoLocalizedTextDtoType } from '../api/bookito-event.dto';
+export declare function resolveLocalizedText(value: BookitoLocalizedTextDtoType, language?: string): string | null;