@wix/headless-restaurants-olo 0.0.33 → 0.0.35

package/dist/services/fulfillments-service.js

@@ -2,8 +2,8 @@ import { defineService, implementService } from '@wix/services-definitions';
 import { SignalsServiceDefinition } from '@wix/services-definitions/core-services/signals';
 import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
 import * as fulfillemtMethodsSDK from '@wix/auto_sdk_restaurants_fulfillment-methods';
-import { processFulfillments, processFulfillmentTimeSlotByOperationList, } from '../utils/fulfillments-utils.js';
-import { DispatchType, } from '../types/fulfillments-types.js';
+import { convertDateToTimezone, getLocale, getTimezone, processFulfillments, processFulfillmentTimeSlotByOperationList, } from '../utils/fulfillments-utils.js';
+import { DispatchType, FulfillmentTypeEnum, } from '../types/fulfillments-types.js';
 export const FulfillmentsServiceDefinition = defineService('fulfillments');
 export const FulfillmentsService = implementService.withConfig()(FulfillmentsServiceDefinition, ({ getService, config }) => {
     if (!config.operation) {
@@ -12,42 +12,80 @@ export const FulfillmentsService = implementService.withConfig()(FulfillmentsSer
     const signalsService = getService(SignalsServiceDefinition);
     const firstAvailableTimeSlotsByOperationList = new Map(config.firstAvailableTimeSlots?.map(processFulfillmentTimeSlotByOperationList) ?? []);
     const fulfillments = signalsService.signal(config.fulfillments ?? []);
-    const firstAvailableTimeSlots = signalsService.signal(firstAvailableTimeSlotsByOperationList.get(
-    // @ts-expect-error - operation is not typed
-    config.operation?.id ?? '') ?? []);
+    const firstAvailableTimeSlots = signalsService.signal(firstAvailableTimeSlotsByOperationList.get(config.operation?.id ?? '') ?? []);
     const isLoading = signalsService.signal(false);
     const error = signalsService.signal(null);
     const dispatchesInfoSignal = signalsService.signal({});
     const selectedDispatchInfoSignal = signalsService.signal(null);
     const asapTimeSignal = signalsService.signal(undefined);
     const asapTimeRangeSignal = signalsService.signal(undefined);
-    processFulfillments(fulfillments.get() ?? [], firstAvailableTimeSlots.get() ?? [], config.operation ?? undefined).then((result) => {
-        const { dispatchesInfo } = result ?? {};
-        dispatchesInfoSignal.set(dispatchesInfo ?? {});
-        const selectedDispatchInfo = dispatchesInfoSignal.get()[selectedFulfillment.get()?.type];
-        selectedDispatchInfoSignal.set(selectedDispatchInfo ?? null);
-        const { maxTimeOptions, durationRangeOptions } = selectedDispatchInfo ?? {};
-        // const isDelivery = !!address;
-        const isAsap = !!selectedTimeSlot.get()?.startsNow;
-        // if (isDelivery && isAsap) {
-        const { fulfillmentDetails } = selectedTimeSlot.get() ?? {};
-        if (isAsap) {
-            asapTimeSignal.set(fulfillmentDetails?.maxTimeOptions ?? maxTimeOptions);
-            asapTimeRangeSignal.set(fulfillmentDetails?.durationRangeOptions ?? durationRangeOptions);
-        }
-    });
+    const selectedFulfillment = signalsService.signal(null);
     const pickupTimeSlot = firstAvailableTimeSlots
         .get()
         ?.find((t) => t.dispatchType === DispatchType.PICKUP) ?? null;
     const initialSelected = pickupTimeSlot ?? firstAvailableTimeSlots.get()?.[0] ?? null;
     const selectedTimeSlot = signalsService.signal(initialSelected);
-    const selectedFulfillment = signalsService.signal(null);
+    const { dispatchesInfo } = processFulfillments(fulfillments.get() ?? [], firstAvailableTimeSlots.get() ?? [], config.operation ?? undefined) ?? {};
+    // Initialize selected fulfillment for initial time slot
+    if (initialSelected && fulfillments.get()?.length > 0) {
+        const timezone = getTimezone();
+        const locale = getLocale();
+        initialSelected.startTime = convertDateToTimezone(initialSelected.startTime, timezone, locale);
+        initialSelected.endTime = convertDateToTimezone(initialSelected.endTime, timezone, locale);
+        const fulfillmentList = fulfillments.get();
+        const matchingFulfillment = fulfillmentList.find((f) => f.type === initialSelected.dispatchType) ?? null;
+        selectedFulfillment.set(matchingFulfillment);
+    }
+    dispatchesInfoSignal.set(dispatchesInfo ?? {});
+    const selectedDispatchInfo = dispatchesInfoSignal.get()[selectedFulfillment.get()?.type];
+    selectedDispatchInfoSignal.set(selectedDispatchInfo ?? null);
+    const { maxTimeOptions, durationRangeOptions } = selectedDispatchInfo ?? {};
+    // const isDelivery = !!address;
+    const isAsap = !!selectedTimeSlot.get()?.startsNow;
+    // if (isDelivery && isAsap) {
+    const { fulfillmentDetails } = selectedTimeSlot.get() ?? {};
+    if (isAsap) {
+        asapTimeSignal.set(fulfillmentDetails?.maxTimeOptions ?? maxTimeOptions);
+        asapTimeRangeSignal.set(fulfillmentDetails?.durationRangeOptions ?? durationRangeOptions);
+    }
+    // });
     const availableTypes = signalsService.signal([]);
+    const getSchedulingType = (timeSlot) => {
+        if (!timeSlot)
+            return undefined;
+        if (config.operation?.operationType === operationsSDK.SchedulingType.ASAP) {
+            return timeSlot.startsNow
+                ? FulfillmentTypeEnum.ASAP
+                : FulfillmentTypeEnum.ASAP_AND_FUTURE;
+        }
+        return FulfillmentTypeEnum.PREORDER;
+    };
+    const schedulingType = signalsService.signal(getSchedulingType(initialSelected));
+    // Compute initial fulfillment type options based on time slots
+    const computeFulfillmentTypeOptions = (timeSlots) => {
+        const hasAsap = timeSlots
+            .filter((slot) => slot.dispatchType === selectedFulfillment.get()?.type)
+            .some((slot) => slot.startsNow);
+        const hasFuture = !!config.operation?.allowAsapFutureHandling;
+        return {
+            hasAsapOption: hasAsap,
+            hasPreorderOption: !hasAsap && hasFuture,
+            hasAsapAndFutureOption: hasAsap && hasFuture,
+        };
+    };
+    const initialOptions = computeFulfillmentTypeOptions(firstAvailableTimeSlots.get() ?? []);
+    const hasAsapOption = signalsService.signal(initialOptions.hasAsapOption);
+    const hasPreorderOption = signalsService.signal(initialOptions.hasPreorderOption);
+    const hasAsapAndFutureOption = signalsService.signal(initialOptions.hasAsapAndFutureOption);
     selectedTimeSlot.set(initialSelected);
     const selectFulfillmentType = (type) => {
         const timeSlot = firstAvailableTimeSlots.get()?.find((t) => t.dispatchType === type) ??
             null;
         if (timeSlot) {
+            const timezone = getTimezone();
+            const locale = getLocale();
+            timeSlot.startTime = convertDateToTimezone(timeSlot.startTime, timezone, locale);
+            timeSlot.endTime = convertDateToTimezone(timeSlot.endTime, timezone, locale);
             setSelectedTimeSlot(timeSlot);
         }
     };
@@ -56,39 +94,21 @@ export const FulfillmentsService = implementService.withConfig()(FulfillmentsSer
      * This action updates:
      * - selectedTimeSlot signal
      * - selectedFulfillment signal (based on dispatch type)
+     * - schedulingType signal (based on order scheduling type)
      * - minOrderPrice signal (based on fulfillment method)
      */
     const setSelectedTimeSlot = (timeSlot) => {
+        console.log('setSelectedTimeSlot', timeSlot);
         // Update the selected time slot
         selectedTimeSlot.set(timeSlot);
+        // Update scheduling type based on order scheduling configuration
+        schedulingType.set(getSchedulingType(timeSlot));
         // Update selected fulfillment based on dispatch type
         const matchingFulfillment = fulfillments.get().find((f) => f.type === timeSlot.dispatchType) ??
             null;
         selectedFulfillment.set(matchingFulfillment);
         selectedDispatchInfoSignal.set(dispatchesInfoSignal.get()[matchingFulfillment?.type] ?? null);
     };
-    // Initialize selected fulfillment for initial time slot
-    if (initialSelected && fulfillments.get()?.length > 0) {
-        const fulfillmentList = fulfillments.get();
-        const matchingFulfillment = fulfillmentList.find((f) => f.type === initialSelected.dispatchType) ?? null;
-        selectedFulfillment.set(matchingFulfillment);
-    }
-    // Load time slots and fulfillments if not provided
-    if (!config.firstAvailableTimeSlots && config.operation) {
-        loadFulfillmentsServiceConfig(config.operation).then((loadedConfig) => {
-            const timeSlotsMap = new Map(loadedConfig.firstAvailableTimeSlots?.map(processFulfillmentTimeSlotByOperationList) ?? []);
-            const newTimeSlots = 
-            // @ts-expect-error - operation is not typed
-            timeSlotsMap.get(loadedConfig.operation?.id ?? '') ?? [];
-            firstAvailableTimeSlots.set(newTimeSlots);
-            fulfillments.set(loadedConfig.fulfillments ?? []);
-            // Set initial time slot using the action to ensure all related signals are updated
-            const newInitialSelected = newTimeSlots[0];
-            if (newInitialSelected) {
-                setSelectedTimeSlot(newInitialSelected);
-            }
-        });
-    }
     availableTypes.set(Array.from(new Set(firstAvailableTimeSlots.get()?.map((t) => t.dispatchType) ?? [])).sort((a, _) => (a === DispatchType.PICKUP ? -1 : 1)));
     return {
         firstAvailableTimeSlots,
@@ -100,6 +120,10 @@ export const FulfillmentsService = implementService.withConfig()(FulfillmentsSer
         asapTimeRangeSignal,
         selectedTimeSlot,
         availableTypes,
+        schedulingType,
+        hasAsapOption,
+        hasPreorderOption,
+        hasAsapAndFutureOption,
         isLoading,
         error,
         setSelectedTimeSlot,

package/dist/services/index.d.ts

@@ -2,3 +2,5 @@ export { ItemService, ItemServiceDefinition, loadItemServiceConfig, ItemServiceC
 export { OLOSettingsService, OLOSettingsServiceDefinition, loadOLOSettingsServiceConfig, type OLOSettingsServiceConfig, type OLOSettingsServiceAPI, } from './olo-settings-service.js';
 export { AvailabilityStatus, AvailabilityStatusMap, RuleType, RuleTypeMap, AddToCartButtonState, AddToCartButtonLabelMap, } from './common-types.js';
 export { FulfillmentsService, FulfillmentsServiceDefinition, loadFulfillmentsServiceConfig, } from './fulfillments-service.js';
+export { type FulfillmentsServiceConfig } from '../types/fulfillments-types.js';
+export { FulfillmentDetailsService, FulfillmentDetailsServiceDefinition, loadFulfillmentDetailsServiceConfig, type FulfillmentDetailsServiceAPI, type FulfillmentDetailsServiceConfig, type AvailableDate, } from './fulfillment-details-service.js';

package/dist/services/index.js

@@ -2,3 +2,4 @@ export { ItemService, ItemServiceDefinition, loadItemServiceConfig, } from './it
 export { OLOSettingsService, OLOSettingsServiceDefinition, loadOLOSettingsServiceConfig, } from './olo-settings-service.js';
 export { AvailabilityStatus, RuleType, AddToCartButtonState, } from './common-types.js';
 export { FulfillmentsService, FulfillmentsServiceDefinition, loadFulfillmentsServiceConfig, } from './fulfillments-service.js';
+export { FulfillmentDetailsService, FulfillmentDetailsServiceDefinition, loadFulfillmentDetailsServiceConfig, } from './fulfillment-details-service.js';

package/dist/services/item-details-service.d.ts

@@ -16,6 +16,7 @@ export interface ItemServiceAPI {
     quantity: Signal<number>;
     specialRequest: Signal<string>;
     lineItem: ReadOnlySignal<LineItem>;
+    onHandleAddToCart: (onClick: (lineItem: LineItem) => void) => void;
     buttonState: ReadOnlySignal<AddToCartButtonState | undefined>;
     addToCartButtonDisabled: Signal<boolean>;
     price: ReadOnlySignal<number>;
@@ -43,7 +44,6 @@ export interface ItemServiceAPI {
         endDate?: Date;
         weeklyAvailabilitySummary?: WeeklyAvailability;
     };
-    doesModifierGroupHaveError: ReadOnlySignal<boolean>;
 }
 /**
  * Service definition for the Item service.

package/dist/services/item-details-service.js

@@ -1,7 +1,7 @@
 import { defineService, implementService } from '@wix/services-definitions';
 import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
 import { AddToCartButtonState, AvailabilityStatus, } from './common-types.js';
-import { getAreNotEnoughModifiersOfMandatoryModifierGroupInStock, getModifiersInitState, getLineItemModifiers, getPriceVariantOptions, getSelectedModifierPrices, getSelectedVariantPrice, calculateItemPrice, checkModifiersValidation, } from './utils.js';
+import { getAreNotEnoughModifiersOfMandatoryModifierGroupInStock, getModifiersInitState, getLineItemModifiers, getPriceVariantOptions, getSelectedModifierPrices, getSelectedVariantPrice, calculateItemPrice, getModifierGroupErrors, } from './utils.js';
 import { OLOSettingsServiceDefinition } from './olo-settings-service.js';
 /**
  * Service definition for the Item service.
@@ -131,6 +131,14 @@ export const ItemService = implementService.withConfig()(ItemServiceDefinition,
             },
         };
     });
+    const onHandleAddToCart = (onClick) => {
+        const currentSelectedModifiers = selectedModifiers.get();
+        const { errors, hasError } = getModifierGroupErrors(currentSelectedModifiers, modifierGroups);
+        modifierGroupError.set(errors);
+        if (hasError)
+            return;
+        onClick(lineItem.get());
+    };
     const updateQuantity = (_quantity) => {
         quantity.set(_quantity);
     };
@@ -164,20 +172,6 @@ export const ItemService = implementService.withConfig()(ItemServiceDefinition,
             }
         }
     };
-    const doesModifierGroupHaveError = signalsService.computed(() => {
-        const currentSelectedModifiers = selectedModifiers.get();
-        const errors = {};
-        modifierGroups.forEach((group) => {
-            if (group._id) {
-                const selectedCount = (currentSelectedModifiers[group._id] || [])
-                    .length;
-                const isValid = checkModifiersValidation(group.rule, selectedCount);
-                errors[group._id] = !isValid;
-            }
-        });
-        modifierGroupError.set(errors);
-        return Object.values(errors).some((error) => error);
-    });
     const toggleModifier = (modifierGroupId, modifierId, singleSelect = false) => {
         const currentSelectedModifiers = selectedModifiers.get();
         const modifierIds = getModifierIds(modifierGroupId, modifierId, singleSelect);
@@ -206,6 +200,7 @@ export const ItemService = implementService.withConfig()(ItemServiceDefinition,
         error,
         specialRequest,
         lineItem,
+        onHandleAddToCart,
         selectedVariant,
         selectedModifiers,
         availabilityStatus,
@@ -215,7 +210,6 @@ export const ItemService = implementService.withConfig()(ItemServiceDefinition,
         addToCartButtonDisabled,
         price,
         futureAvailability,
-        doesModifierGroupHaveError,
     };
 });
 /**

package/dist/services/olo-settings-service.d.ts

@@ -4,7 +4,6 @@ import { MenusServiceConfig } from '@wix/restaurants/services';
 export interface OLOSettingsServiceAPI {
     operationGroup: Signal<operationGroupsSDK.OperationGroup | undefined>;
     operation: Signal<operationsSDK.Operation | undefined>;
-    selectedItem?: Signal<unknown>;
     isLoading: Signal<boolean>;
     error: Signal<string | null>;
     availabilityDispatchAction?: Signal<(() => void) | undefined>;

package/dist/services/olo-settings-service.js

@@ -10,8 +10,7 @@ export const OLOSettingsService = implementService.withConfig()(OLOSettingsServi
     const operation = signalsService.signal(config.operation);
     const formatCurrency = config.formattedPrice ??
         ((price) => price?.toFixed(2)?.toString() ?? '');
-    const selectedItem = signalsService.signal(null);
-    const isLoading = signalsService.signal(false);
+    const isLoading = signalsService.signal(true);
     const error = signalsService.signal(null);
     const currentFulfillment = signalsService.signal('Pickup');
     const currentTimeSlot = signalsService.signal('10-14');
@@ -24,7 +23,6 @@ export const OLOSettingsService = implementService.withConfig()(OLOSettingsServi
         operation,
         isLoading,
         error,
-        selectedItem,
         availabilityDispatchAction,
         currentFulfillment,
         currentTimeSlot,

package/dist/services/utils.d.ts

@@ -35,6 +35,10 @@ export declare const chooseUpToX: ({ required, minSelections, maxSelections, }:
 export declare const hasToChooseBetweenXAndY: ({ required, minSelections, maxSelections, }: ruleUtilsArgs) => boolean;
 export declare const getRuleTypeMapValue: (ruleTypeMap: RuleTypeMap, ruleType: RuleType, rule: EnhancedModifierGroup["rule"]) => string | undefined;
 export declare const checkModifiersValidation: (rule: EnhancedModifierGroup["rule"], selectedCount: number) => boolean;
+export declare const getModifierGroupErrors: (selectedModifiers: Record<string, Array<string>>, modifierGroups: EnhancedModifierGroup[]) => {
+    errors: Record<string, boolean>;
+    hasError: boolean;
+};
 export declare const getAreNotEnoughModifiersOfMandatoryModifierGroupInStock: (modifierGroups: EnhancedModifierGroup[]) => boolean;
 export declare const getLineItemModifiers: (selectedModifiers: Record<string, Array<string>>, modifierGroups: EnhancedModifierGroup[], formatCurrency: (price?: number) => string) => {
     id: string;

package/dist/services/utils.js

@@ -158,6 +158,18 @@ export const checkModifiersValidation = (rule, selectedCount) => {
     }
     return true;
 };
+export const getModifierGroupErrors = (selectedModifiers, modifierGroups) => {
+    const errors = {};
+    modifierGroups.forEach((group) => {
+        if (group._id) {
+            const selectedCount = (selectedModifiers[group._id] || []).length;
+            const isValid = checkModifiersValidation(group.rule, selectedCount);
+            errors[group._id] = !isValid;
+        }
+    });
+    const hasError = Object.values(errors).some((error) => error);
+    return { errors, hasError };
+};
 export const getAreNotEnoughModifiersOfMandatoryModifierGroupInStock = (modifierGroups) => modifierGroups.some((modifierGroup) => {
     const isModifierGroupMandatory = modifierGroup.rule?.required;
     const minimumRequiredModifiers = modifierGroup.rule?.minSelections ?? 0;

package/dist/types/fulfillments-types.d.ts

@@ -2,12 +2,21 @@ import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
 import { Signal } from '@wix/services-definitions/core-services/signals';
 import * as fulfillemtMethodsSDK from '@wix/auto_sdk_restaurants_fulfillment-methods';
 import { Address, DurationRange } from '@wix/auto_sdk_restaurants_operations';
+import { Operation } from './operation.js';
 export declare enum DispatchType {
     /** Pickup fulfillment */
     PICKUP = "PICKUP",
     /** Delivery fulfillment */
     DELIVERY = "DELIVERY"
 }
+export declare enum FulfillmentTypeEnum {
+    /** ASAP - Order will be fulfilled as soon as possible */
+    ASAP = "ASAP",
+    /** PREORDER - Order will be fulfilled at a scheduled time */
+    PREORDER = "PREORDER",
+    /** ASAP_AND_FUTURE - Both ASAP and future scheduling available */
+    ASAP_AND_FUTURE = "ASAP_AND_FUTURE"
+}
 export type TimeSlot = {
     id: string;
     startTime: Date;
@@ -52,6 +61,14 @@ export interface FulfillmentsServiceAPI {
     error: Signal<string | null>;
     /** Available dispatch types */
     availableTypes: Signal<DispatchType[]>;
+    /** Current scheduling type (ASAP or PREORDER) based on selected time slot */
+    schedulingType: Signal<FulfillmentTypeEnum | undefined>;
+    /** Whether ASAP option is available */
+    hasAsapOption: Signal<boolean>;
+    /** Whether preorder (schedule for later) option is available */
+    hasPreorderOption: Signal<boolean>;
+    /** Whether both ASAP and future scheduling options are available */
+    hasAsapAndFutureOption: Signal<boolean>;
     /**
      * Dispatches info by dispatch type
      */
@@ -78,6 +95,6 @@ export interface FulfillmentsServiceAPI {
 }
 export interface FulfillmentsServiceConfig {
     firstAvailableTimeSlots?: operationsSDK.TimeSlotForOperation[];
-    operation?: operationsSDK.Operation;
+    operation?: Operation;
     fulfillments?: fulfillemtMethodsSDK.FulfillmentMethod[];
 }

package/dist/types/fulfillments-types.js

@@ -5,3 +5,12 @@ export var DispatchType;
     /** Delivery fulfillment */
     DispatchType["DELIVERY"] = "DELIVERY";
 })(DispatchType || (DispatchType = {}));
+export var FulfillmentTypeEnum;
+(function (FulfillmentTypeEnum) {
+    /** ASAP - Order will be fulfilled as soon as possible */
+    FulfillmentTypeEnum["ASAP"] = "ASAP";
+    /** PREORDER - Order will be fulfilled at a scheduled time */
+    FulfillmentTypeEnum["PREORDER"] = "PREORDER";
+    /** ASAP_AND_FUTURE - Both ASAP and future scheduling available */
+    FulfillmentTypeEnum["ASAP_AND_FUTURE"] = "ASAP_AND_FUTURE";
+})(FulfillmentTypeEnum || (FulfillmentTypeEnum = {}));

package/dist/utils/date-utils.d.ts

@@ -0,0 +1,164 @@
+import { TimeOfDay, TimeOfDayRange, EntitiesDayOfWeek as DayOfWeek } from '@wix/auto_sdk_restaurants_fulfillment-methods';
+export { TimeOfDay, TimeOfDayRange, DayOfWeek };
+/**
+ * Get the current locale
+ * Uses the configured locale, falls back to i18n.getLocale()
+ *
+ * @returns The current locale string
+ */
+export declare const getLocale: () => string;
+/**
+ * Get the current timezone
+ * Uses the configured timezone, falls back to undefined (browser default)
+ *
+ * @returns The current timezone string or undefined
+ */
+export declare const getTimezone: () => string | undefined;
+/**
+ * Mapping of day of week enum to numeric value (1-7, Monday-Sunday)
+ */
+export declare const DAY_OF_WEEK: {
+    MON: number;
+    TUE: number;
+    WED: number;
+    THU: number;
+    FRI: number;
+    SAT: number;
+    SUN: number;
+};
+/**
+ * Extract date/time parts from a Date in a specific timezone
+ * @param date - The source Date object
+ * @param timezone - The target timezone (e.g., 'America/New_York'). Defaults to configured timezone.
+ * @param locale - The locale for formatting (e.g., 'en-US'). Defaults to configured locale.
+ * @param includeTime - Whether to include time parts (hour, minute, second)
+ * @returns Object containing the extracted date/time parts
+ */
+export declare const getDatePartsInTimezone: (date: Date, timezone?: string, locale?: string, includeTime?: boolean) => {
+    year: string;
+    month: string;
+    day: string;
+    hour?: string;
+    minute?: string;
+    second?: string;
+};
+/**
+ * Build a Date from date/time parts
+ * @param year - Year string
+ * @param month - Month string (2-digit)
+ * @param day - Day string (2-digit)
+ * @param hour - Hour string (2-digit, optional)
+ * @param minute - Minute string (2-digit, optional)
+ * @param second - Second string (2-digit, optional)
+ * @returns A new Date object
+ */
+export declare const buildDateFromParts: (year: string, month: string, day: string, hour?: string, minute?: string, second?: string) => Date;
+/**
+ * Convert a TimeOfDay object to a Date object
+ * Creates a Date for today with the specified time in the target timezone.
+ * Equivalent to: DateTime.fromObject({ hour, minute }).setZone(timezone, { keepLocalTime: true })
+ *
+ * @param time - TimeOfDay object with hours and minutes
+ * @param timezone - The target timezone (e.g., 'America/New_York'). Defaults to configured timezone.
+ * @returns A Date object representing the time in the specified timezone
+ */
+export declare const convertTimeOfDayToDateTime: (time: TimeOfDay, timezone?: string) => Date;
+/**
+ * Convert a Date to a Date adjusted for a specific timezone
+ * This is useful when you need to display or compare dates in a specific timezone
+ *
+ * @param date - The source Date object
+ * @param timezone - The target timezone (e.g., 'America/New_York'). Defaults to configured timezone.
+ * @param locale - The locale for formatting (e.g., 'en-US'). Defaults to configured locale.
+ * @returns A new Date object adjusted to represent the same moment in the target timezone
+ */
+export declare const convertDateToTimezone: (date: Date, timezone?: string, locale?: string) => Date;
+/**
+ * Format a Date as a localized string for a specific timezone and locale
+ *
+ * @param date - The source Date object
+ * @param timezone - The target timezone (e.g., 'America/New_York'). Defaults to configured timezone.
+ * @param locale - The locale for formatting (e.g., 'en-US'). Defaults to configured locale.
+ * @param options - Additional Intl.DateTimeFormatOptions
+ * @returns A formatted date string
+ */
+export declare const formatDateInTimezone: (date: Date, timezone?: string, locale?: string, options?: Intl.DateTimeFormatOptions) => string;
+/**
+ * Check if a time falls within a time range
+ *
+ * @param time - The time to check
+ * @param range - The time range to check against
+ * @param timeZone - The timezone for conversion. Defaults to configured timezone.
+ * @param locale - The locale for formatting. Defaults to configured locale.
+ * @returns True if the time is within the range
+ */
+export declare const isInTimeRange: (time: Date, range: TimeOfDayRange, timeZone?: string) => boolean;
+/**
+ * Get the current day of week as a number (1-7, Monday-Sunday)
+ * JavaScript's getDay() returns 0 (Sunday) to 6 (Saturday),
+ * this function converts to 1 (Monday) to 7 (Sunday)
+ *
+ * @param date - The date to get the day of week from
+ * @returns The day of week as a number (1-7)
+ */
+export declare const getDayOfWeekNumber: (date: Date) => number;
+/**
+ * Format a date as time only (e.g., "10:30 AM")
+ * Uses configured locale and timezone
+ *
+ * @param date - The date to format
+ * @param options - Additional Intl.DateTimeFormatOptions (defaults to hour:numeric, minute:numeric)
+ * @returns A formatted time string, or empty string if date is undefined
+ */
+export declare const formatTime: (date?: Date, options?: Intl.DateTimeFormatOptions) => string;
+/**
+ * Format a time range as a localized string
+ * If start and end times are the same, returns just the time
+ * Otherwise returns "start - end" format
+ *
+ * @param startTime - The start time
+ * @param endTime - The end time
+ * @param options - Additional Intl.DateTimeFormatOptions (defaults to hour:numeric, minute:numeric, hour12:true)
+ * @returns A formatted time range string
+ */
+export declare const formatTimeRange: (startTime: Date, endTime: Date, options?: Intl.DateTimeFormatOptions) => string;
+/**
+ * Check if two dates are on the same calendar day
+ * Compares year, month, and day components
+ *
+ * @param date1 - The first date to compare
+ * @param date2 - The second date to compare
+ * @returns True if both dates are on the same calendar day
+ */
+export declare const isSameDay: (date1: Date, date2: Date) => boolean;
+/**
+ * Get today's date with time set to midnight (00:00:00.000)
+ *
+ * @returns A Date object representing the start of today
+ */
+export declare const getToday: () => Date;
+/**
+ * Get a future date with time set to 23:59:59.999
+ *
+ * @param days - The number of days to add to the current date
+ * @returns A Date object representing the end of the future date
+ */
+export declare const getFutureDate: (days: number) => Date;
+/**
+ * Create a Date object from year, month, and day numbers
+ * Adjusts for timezone offset to ensure the date represents the correct local date
+ *
+ * @param year - The year (e.g., 2024)
+ * @param month - The month (1-12, where 1 is January)
+ * @param day - The day of the month (1-31)
+ * @returns A Date object representing midnight on the specified date in local time
+ */
+export declare const createDateFromYMD: (year: number, month: number, day: number) => Date;
+/**
+ * Format a Date as an ISO date string (YYYY-MM-DD)
+ * Useful for HTML date input values and attributes
+ *
+ * @param date - The date to format
+ * @returns A string in YYYY-MM-DD format
+ */
+export declare const toISODateString: (date: Date) => string;