@wix/headless-restaurants-olo 0.0.13 → 0.0.15

package/cjs/dist/types/operation.d.ts

@@ -0,0 +1,57 @@
+import { DispatchType } from './fulfillments-types.js';
+export type MinMaxRange = {
+    min: number;
+    max: number;
+};
+export type AsapScheduling = {
+    maxInMinutes?: number;
+    rangeInMinutes?: MinMaxRange;
+};
+export type PreorderScheduling = {
+    timeWindowDuration: number;
+    timeInAdvance: MinMaxRange;
+};
+export type OperationType = 'PRE_ORDER' | 'ASAP';
+type BaseOperation = {
+    id: string;
+    name: string;
+};
+export interface StreetAddress {
+    apt?: String;
+    formattedAddressLine?: String;
+    name?: String;
+    number?: String;
+}
+export interface Address {
+    addressLine?: String;
+    addressLine2?: String;
+    city?: String;
+    country?: String;
+    countryFullname?: String;
+    formattedAddress?: String;
+    hint?: String;
+    postalCode?: String;
+    streetAddress?: StreetAddress;
+    subdivision?: String;
+    subdivisionFullname?: String;
+}
+export type OSLocation = {
+    name: string;
+    address?: Address;
+    default?: boolean;
+    timeZone?: string;
+};
+export type Operation = BaseOperation & {
+    enabled: boolean;
+    fulfillmentIds: string[];
+    asapOptions?: AsapScheduling;
+    allowAsapFutureHandling?: boolean;
+    businessDaysAheadHandlingOptions?: number;
+    operationType: OperationType;
+    preOrderOptions?: PreorderScheduling;
+    defaultDispatchType?: DispatchType;
+    operationGroupId: string;
+    locationId: string;
+    locationDetails?: OSLocation;
+};
+export {};

package/cjs/dist/types/operation.js

@@ -0,0 +1 @@
+export {};

package/cjs/dist/utils/fulfillments-utils.d.ts

@@ -0,0 +1,23 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { TimeSlot } from '../types/fulfillments-types.js';
+export declare const createTimeSlotId: (startTime: Date, endTime: Date, maxTimeOptions?: number) => string;
+export declare function hasSameByField<T>(field: keyof T, arr: T[]): boolean;
+export declare function getMinValueObjects<T>(key: keyof T, arr: T[]): T[];
+export declare function getMinTime(info: operationsSDK.FulfillmentInfo): number;
+export declare function getFastestTimeOptionsByFulfillmentInfo(arr: operationsSDK.FulfillmentInfo[]): operationsSDK.FulfillmentInfo[];
+export declare function getSlowestTimeOptionByFulfillmentInfo(arr: operationsSDK.FulfillmentInfo[]): operationsSDK.FulfillmentInfo;
+export declare const createTimeRangeByFulfillmentInfo: (arr: operationsSDK.FulfillmentInfo[]) => {
+    maxTimeOptions: number | undefined;
+    durationRangeOptions?: undefined;
+} | {
+    durationRangeOptions: {
+        minDuration: number | undefined;
+        maxDuration: number | undefined;
+    };
+    maxTimeOptions?: undefined;
+};
+export declare function hasSameTime(arr: operationsSDK.FulfillmentDetails[]): boolean;
+export declare const resolveDifferentMinOrderPriceOptionByFulfillmentInfo: (fulfillmentInfo: operationsSDK.FulfillmentInfo[]) => operationsSDK.FulfillmentInfo | undefined;
+export declare const resolveSameMinOrderPriceOptionByFulfillmentInfo: (fulfillmentInfo: operationsSDK.FulfillmentInfo[]) => operationsSDK.FulfillmentInfo;
+export declare const resolveFulfillmentInfo: (fulfillmentInfo: operationsSDK.FulfillmentInfo[]) => operationsSDK.FulfillmentInfo | undefined;
+export declare const processFulfillmentTimeSlotByOperationList: (operationTimeSlot: operationsSDK.TimeSlotForOperation) => [string, TimeSlot[] | undefined];

package/cjs/dist/utils/fulfillments-utils.js

@@ -0,0 +1,144 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { DispatchType } from '../types/fulfillments-types.js';
+export const createTimeSlotId = (startTime, endTime, maxTimeOptions = 0) => 
+// maxTimeOptions is used to avoid collisions when order pacing is enabled
+`${startTime?.toUTCString()}-${endTime?.toUTCString()}-${maxTimeOptions}`;
+export function hasSameByField(field, arr) {
+    const [first, ...rest] = arr;
+    return rest.every((item) => item[field] === first?.[field]);
+}
+export function getMinValueObjects(key, arr) {
+    return arr.slice(1).reduce((min, item) => {
+        if (Number(item[key]) < Number(min[0]?.[key])) {
+            return [item];
+        }
+        else if (Number(item[key]) === Number(min[0]?.[key])) {
+            return [...min, item];
+        }
+        return min;
+    }, (arr[0] ? [arr[0]] : []));
+}
+export function getMinTime(info) {
+    return info.durationRange
+        ? Number(info.durationRange.minDuration)
+        : Number(info.maxTime);
+}
+export function getFastestTimeOptionsByFulfillmentInfo(arr) {
+    const [first, ...rest] = arr;
+    if (!first) {
+        return [];
+    }
+    return rest.reduce((fastestOptions, current) => {
+        const currentTime = getMinTime(current);
+        const fastestTime = getMinTime(fastestOptions[0]);
+        if (currentTime < fastestTime) {
+            return [current];
+        }
+        else if (currentTime === fastestTime) {
+            return [...fastestOptions, current];
+        }
+        return fastestOptions;
+    }, [first]);
+}
+export function getSlowestTimeOptionByFulfillmentInfo(arr) {
+    return arr.reduce((max, item) => {
+        const { durationRange, maxTime: maxTimeOptions } = item;
+        let maxTime;
+        if (max.durationRange) {
+            maxTime = Number(max.durationRange?.maxDuration || 0);
+        }
+        else {
+            maxTime = Number(max.maxTime || 0);
+        }
+        if (durationRange) {
+            return Number(durationRange.maxDuration) > maxTime ? item : max;
+        }
+        else {
+            return Number(maxTimeOptions) > maxTime ? item : max;
+        }
+    }, {});
+}
+export const createTimeRangeByFulfillmentInfo = (arr) => {
+    const fastestOption = getFastestTimeOptionsByFulfillmentInfo(arr)[0];
+    const slowestOption = getSlowestTimeOptionByFulfillmentInfo(arr);
+    const minDuration = fastestOption?.durationRange?.minDuration ?? fastestOption?.maxTime;
+    const maxDuration = slowestOption.durationRange?.maxDuration ?? slowestOption.maxTime;
+    if (minDuration === maxDuration) {
+        return { maxTimeOptions: minDuration };
+    }
+    else {
+        return { durationRangeOptions: { minDuration, maxDuration } };
+    }
+};
+export function hasSameTime(arr) {
+    return (hasSameByField('fulfillmentTimeType', arr) &&
+        (arr[0]?.fulfillmentTimeType === operationsSDK.FulfillmentTimeType.MAX_TIME
+            ? hasSameByField('maxTimeOptions', arr)
+            : arr.every((details) => {
+                const { durationRangeOptions } = details;
+                return (durationRangeOptions?.maxDuration ===
+                    arr[0]?.durationRangeOptions?.maxDuration &&
+                    durationRangeOptions?.minDuration ===
+                        arr[0]?.durationRangeOptions?.minDuration);
+            })));
+}
+export const resolveDifferentMinOrderPriceOptionByFulfillmentInfo = (fulfillmentInfo) => {
+    const hasSameFee = hasSameByField('fee', fulfillmentInfo);
+    if (hasSameFee && hasSameTime(fulfillmentInfo)) {
+        // if fee and time are the same, return the object with the min order price with the min free delivery price threshold
+        return getMinValueObjects('freeFulfillmentPriceThreshold', getMinValueObjects('minOrderPrice', fulfillmentInfo))[0];
+    }
+    else {
+        // if the fee is the same and time is different, return the fee
+        const fee = hasSameFee ? fulfillmentInfo[0]?.fee : undefined;
+        // if free delivery price threshold is the same, return free delivery price threshold
+        const freeFulfillmentPriceThreshold = hasSameByField('freeFulfillmentPriceThreshold', fulfillmentInfo)
+            ? fulfillmentInfo[0]?.freeFulfillmentPriceThreshold
+            : undefined;
+        // create a time range object from all the fulfillments
+        return {
+            fee,
+            ...createTimeRangeByFulfillmentInfo(fulfillmentInfo),
+            freeFulfillmentPriceThreshold,
+        };
+    }
+};
+export const resolveSameMinOrderPriceOptionByFulfillmentInfo = (fulfillmentInfo) => {
+    // filtering fulfillment details by order of precedent: fee, time, free delivery price threshold
+    const cheapestFulfillmentInfo = getMinValueObjects('fee', fulfillmentInfo);
+    const fastestFulfillmentInfo = getFastestTimeOptionsByFulfillmentInfo(cheapestFulfillmentInfo);
+    return getMinValueObjects('freeFulfillmentPriceThreshold', fastestFulfillmentInfo)[0];
+};
+export const resolveFulfillmentInfo = (fulfillmentInfo) => {
+    if (hasSameByField('minOrderPrice', fulfillmentInfo)) {
+        return resolveSameMinOrderPriceOptionByFulfillmentInfo(fulfillmentInfo);
+    }
+    else {
+        return resolveDifferentMinOrderPriceOptionByFulfillmentInfo(fulfillmentInfo);
+    }
+};
+export const processFulfillmentTimeSlotByOperationList = (operationTimeSlot) => {
+    return [
+        operationTimeSlot.operationId ?? '',
+        operationTimeSlot.timeslotsPerFulfillmentType?.map((fulfillmentTimeSlot) => {
+            const { timeSlot, fulfilmentType, fulfillmentInfo } = fulfillmentTimeSlot;
+            const { startTime, endTime, orderSchedulingType } = timeSlot ?? {};
+            const selectedFulfillmentInfo = resolveFulfillmentInfo(fulfillmentInfo);
+            const fulfillmentDetails = {
+                maxTimeOptions: selectedFulfillmentInfo?.maxTime,
+                durationRangeOptions: selectedFulfillmentInfo?.durationRange,
+                ...selectedFulfillmentInfo,
+            };
+            return {
+                id: createTimeSlotId(startTime, endTime),
+                startTime: startTime,
+                endTime: endTime,
+                dispatchType: fulfilmentType === 'DELIVERY'
+                    ? DispatchType.DELIVERY
+                    : DispatchType.PICKUP,
+                startsNow: orderSchedulingType === operationsSDK.OrderSchedulingType.ASAP,
+                fulfillmentDetails,
+            };
+        }),
+    ];
+};

package/dist/mappers/operation-mapper.d.ts

@@ -0,0 +1,3 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { Operation } from '../types/operation.js';
+export declare const OperationMapper: (operation: operationsSDK.Operation) => Operation;

package/dist/mappers/operation-mapper.js

@@ -0,0 +1,95 @@
+import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
+import { DispatchType } from '../types/fulfillments-types.js';
+const TIME_UNIT_MULTIPLIER = {
+    MINUTES: 1,
+    UNKNOWN_TIME_UNIT: 0,
+    DAYS: 24 * 60,
+    HOURS: 60,
+};
+const getAsapOptionsFromOperation = (operation) => {
+    if (!operation.orderScheduling?.asapOptions) {
+        return;
+    }
+    const { timeRangeOptions, maxTimeOptions } = operation.orderScheduling.asapOptions.preparationTime || {};
+    if (maxTimeOptions &&
+        maxTimeOptions.duration !== null &&
+        maxTimeOptions.duration !== undefined &&
+        maxTimeOptions.timeUnit) {
+        return {
+            maxInMinutes: maxTimeOptions.duration * TIME_UNIT_MULTIPLIER[maxTimeOptions.timeUnit],
+        };
+    }
+    if (timeRangeOptions &&
+        timeRangeOptions.timeUnit &&
+        timeRangeOptions.maxDuration !== undefined &&
+        timeRangeOptions.maxDuration !== null &&
+        timeRangeOptions.minDuration !== undefined &&
+        timeRangeOptions.minDuration !== null) {
+        return {
+            rangeInMinutes: {
+                min: timeRangeOptions.minDuration *
+                    TIME_UNIT_MULTIPLIER[timeRangeOptions.timeUnit],
+                max: timeRangeOptions.maxDuration *
+                    TIME_UNIT_MULTIPLIER[timeRangeOptions.timeUnit],
+            },
+        };
+    }
+};
+function getPreOrderOptions(operation) {
+    if (!operation.orderScheduling?.preorderOptions) {
+        return;
+    }
+    const timeBoundedOptions = operation.orderScheduling?.preorderOptions?.method?.timeBoundedOptions;
+    if (!timeBoundedOptions) {
+        return;
+    }
+    const { maxTimeInAdvance, minTimeInAdvance } = timeBoundedOptions;
+    const max = TIME_UNIT_MULTIPLIER[maxTimeInAdvance?.timeUnit] *
+        maxTimeInAdvance?.duration;
+    const min = TIME_UNIT_MULTIPLIER[minTimeInAdvance?.timeUnit] *
+        minTimeInAdvance?.duration;
+    const timeWindowsOptions = operation.orderScheduling?.preorderOptions?.fulfillmentTimesDisplay
+        ?.timeWindowsOptions;
+    const timeWindowDuration = TIME_UNIT_MULTIPLIER[timeWindowsOptions.timeUnit] *
+        timeWindowsOptions.duration;
+    return {
+        timeInAdvance: { min, max },
+        timeWindowDuration,
+    };
+}
+function getOperationType(operation) {
+    switch (operation.orderScheduling?.type) {
+        case operationsSDK.SchedulingType.PREORDER:
+            return 'PRE_ORDER';
+        case operationsSDK.SchedulingType.ASAP:
+        default:
+            return 'ASAP';
+    }
+}
+export const OperationMapper = (operation) => {
+    const { asapFutureHandlingType, businessDaysAheadHandlingOptions } = operation.orderScheduling?.asapOptions || {};
+    const { daysCount } = businessDaysAheadHandlingOptions || {};
+    const allowAsapFutureHandling = asapFutureHandlingType ===
+        operationsSDK.AsapFutureHandlingType.BUSINESS_DAYS_AHEAD_HANDLING &&
+        Number(daysCount) >= 0;
+    return {
+        id: operation._id || '',
+        name: operation.name || '',
+        // @ts-expect-error - operation is not typed
+        enabled: !!operation.enabled,
+        fulfillmentIds: operation.fulfillmentIds || [],
+        asapOptions: getAsapOptionsFromOperation(operation),
+        preOrderOptions: getPreOrderOptions(operation),
+        operationType: getOperationType(operation),
+        allowAsapFutureHandling,
+        businessDaysAheadHandlingOptions: daysCount ?? undefined,
+        defaultDispatchType: operation.defaultFulfillmentType ===
+            operationsSDK.FulfillmentType.DELIVERY
+            ? DispatchType.DELIVERY
+            : DispatchType.PICKUP,
+        operationGroupId: operation.operationGroupId || '',
+        locationId: operation.businessLocationId || '',
+        // @ts-expect-error - operation is not typed
+        locationDetails: operation.businessLocationDetails,
+    };
+};

package/dist/react/ItemDetails.d.ts

@@ -1,6 +1,5 @@
 import React from 'react';
 import { Commerce } from '@wix/ecom/components';
-import { type LineItem } from '@wix/ecom/services';
 import { type AsChildChildren } from '@wix/headless-utils/react';
 import { ItemServiceConfig } from '../services/item-details-service.js';
 import { EnhancedModifier, EnhancedModifierGroup, EnhancedVariant } from '@wix/headless-restaurants-menus/services';
@@ -180,35 +179,6 @@ export interface ItemDetailsVariantsProps {
     variantPriceClassName?: string;
 }
 export declare const Variants: React.ForwardRefExoticComponent<ItemDetailsVariantsProps & React.RefAttributes<HTMLElement>>;
-export interface AddToCartActionProps {
-    /** Whether to render as a child component */
-    asChild?: boolean;
-    /** Text label for the button */
-    label: string;
-    /** Custom render function when using asChild */
-    lineItems: LineItem[];
-    /** CSS classes to apply to the button */
-    className?: string;
-    /** Content to display when loading */
-    loadingState?: string | React.ReactNode;
-    children?: React.ReactNode;
-}
-/**
- * Add to Cart button for the menu item.
- * Triggers the action to add the selected item (and its modifiers/variants) to the cart.
- *
- * @component
- * @example
- * ```tsx
- * <ItemDetails>
- *   <AddToCart
- *     label="Add to Cart"
- *     lineItems={[{ catalogReference: { ... }, quantity: 1 }]}
- *   />
- * </ItemDetails>
- * ```
- */
-export declare const AddToCart: React.ForwardRefExoticComponent<AddToCartActionProps & React.RefAttributes<HTMLButtonElement>>;
 /**
  * Multi-line text input component for special requests or instructions.
  * Provides a textarea for customers to add custom notes or modifications.
@@ -256,7 +226,6 @@ export interface AddToCartButtonProps extends Omit<React.ComponentPropsWithoutRe
     children?: React.ReactNode;
     className?: string;
     label?: string;
-    onClick?: () => void;
 }
 export interface ItemDetailsQuantityProps {
     children: React.ReactNode;

package/dist/react/ItemDetails.js

@@ -89,29 +89,8 @@ export const Variants = React.forwardRef(({ children, className, asChild, varian
         } }));
 });
 Variants.displayName = 'ItemDetails.Variants';
-/**
- * Add to Cart button for the menu item.
- * Triggers the action to add the selected item (and its modifiers/variants) to the cart.
- *
- * @component
- * @example
- * ```tsx
- * <ItemDetails>
- *   <AddToCart
- *     label="Add to Cart"
- *     lineItems={[{ catalogReference: { ... }, quantity: 1 }]}
- *   />
- * </ItemDetails>
- * ```
- */
-export const AddToCart = React.forwardRef(({ lineItems, className, label, ...props }, ref) => {
-    return (_jsx(Commerce.Actions.AddToCart, { ref: ref, asChild: false, label: label, className: className, lineItems: lineItems, children: props.children }));
-});
-AddToCart.displayName = 'AddToCart';
-export const AddToCartButton = ({ asChild = false, children, className, onClick, label = 'Add to cart', ...props }) => {
-    return (_jsx(CoreItemDetails.LineItemComponent, { children: ({ lineItem }) => (_jsx(AsChildSlot, { asChild: asChild, className: className, customElement: children, customElementProps: {
-                onClick,
-            }, children: _jsx(Commerce.Actions.AddToCart, { asChild: false, label: label, className: className, lineItems: [lineItem], ...props, children: children }) })) }));
+export const AddToCartButton = ({ asChild, children, className, label = 'Add to cart', ...props }) => {
+    return (_jsx(CoreItemDetails.LineItemComponent, { children: ({ lineItem }) => (_jsx(Commerce.Actions.AddToCart, { asChild: asChild, label: label, className: className, lineItems: [lineItem], ...props, children: children })) }));
 };
 export const Quantity = ({ children }) => {
     return (_jsx(CoreItemDetails.QuantityComponent, { children: ({ quantity, onValueChange, }) => (_jsx(QuantityComponent.Root, { onValueChange: onValueChange, initialValue: quantity, children: children })) }));

package/dist/react/OLO.d.ts

@@ -1,12 +1,13 @@
 import React from 'react';
 import { ItemServiceConfig } from '../services/item-details-service.js';
+import { OLOSettingsServiceConfig } from '../services/olo-settings-service.js';
 interface OLORootProps {
     /** The ID of the item to load */
     itemId?: string;
     /** Pre-loaded item service config (optional) */
-    itemServiceConfig?: any;
+    itemServiceConfig?: ItemServiceConfig;
     /** Pre-loaded OLO settings service config (optional) */
-    oloSettingsServiceConfig?: any;
+    oloSettingsServiceConfig?: OLOSettingsServiceConfig;
     /** Children render prop that receives the service state */
     children: React.ReactNode;
 }

package/dist/react/OLOMenus.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { type MenusServiceConfig } from '@wix/headless-restaurants-menus/services';
+declare enum TestIds {
+    menusRoot = "menus-root"
+}
+/**
+ * Menus.Root
+ * Container for the menus context and data loading.
+ * Does not render if there are no menus.
+ */
+export interface MenusRootProps {
+    children: React.ReactNode;
+    config: MenusServiceConfig;
+}
+export declare const Root: React.ForwardRefExoticComponent<MenusRootProps & React.RefAttributes<HTMLElement>>;
+export declare const OLOMenus: {
+    Root: React.ForwardRefExoticComponent<MenusRootProps & React.RefAttributes<HTMLElement>>;
+    TestIds: typeof TestIds;
+};
+export {};

package/dist/react/OLOMenus.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Menus } from '@wix/headless-restaurants-menus/react';
+import * as CoreOLOMenus from './core/OLOMenus.js';
+// =======================
+// TestIds Enum
+// =======================
+var TestIds;
+(function (TestIds) {
+    // Container Level
+    TestIds["menusRoot"] = "menus-root";
+})(TestIds || (TestIds = {}));
+export const Root = React.forwardRef((props) => {
+    const { children, config } = props;
+    return (_jsx(CoreOLOMenus.Root, { "data-testid": TestIds.menusRoot, config: config, children: (updatedConfig) => (_jsx(Menus.Root, { "data-testid": TestIds.menusRoot, config: updatedConfig, children: children })) }));
+});
+Root.displayName = 'Menus.Root';
+// Compose Menus namespace
+export const OLOMenus = {
+    Root,
+    TestIds,
+};

package/dist/react/Settings.d.ts

@@ -0,0 +1,160 @@
+import React from 'react';
+import { AsChildChildren } from '@wix/headless-utils/react';
+/**
+ * Root headless component for OLO Settings
+ * Provides access to current details, fulfillment options, location, and extra data
+ *
+ * @example
+ * ```tsx
+ * <Settings.Root>
+ *   {({ currentDetails, currentFulfillment, currentLocation, extraData, isLoading, error }) => (
+ *     isLoading ? (
+ *       <div>Loading settings...</div>
+ *     ) : error ? (
+ *       <div>Error: {error}</div>
+ *     ) : (
+ *       <div>
+ *         <h2>{currentDetails.name}</h2>
+ *         <p>{currentDetails.address}</p>
+ *         <p>Accepting Orders: {extraData.acceptingOrders ? 'Yes' : 'No'}</p>
+ *         <p>Delivery Fee: ${extraData.deliveryFee}</p>
+ *         <p>Min Order: ${extraData.minOrderAmount}</p>
+ *         <p>Free Delivery: ${extraData.freeDeliveryThreshold}</p>
+ *       </div>
+ *     )
+ *   )}
+ * </Settings.Root>
+ * ```
+ */
+interface CurrentTimeSlotProps {
+    /** Children render prop that receives the current details */
+    children?: AsChildChildren<{
+        timeSlot: string;
+    }>;
+    /** CSS classes to apply to the default element */
+    className?: string;
+    /** Whether to render as a child component */
+    asChild?: boolean;
+}
+/**
+ * Headless component for current store details
+ * Provides access to store name, address, contact info, and hours
+ *
+ * @example
+ * ```tsx
+ * <Settings.CurrentTimeSlot>
+ *   {({ details, hasDetails }) => (
+ *     hasDetails ? (
+ *       <div>
+ *         <h3>{details.name}</h3>
+ *         <p>{details.address}</p>
+ *         <p>{details.phone}</p>
+ *         <p>{details.email}</p>
+ *       </div>
+ *     ) : (
+ *       <div>No store details available</div>
+ *     )
+ *   )}
+ * </Settings.CurrentTimeSlot>
+ * ```
+ */
+export declare const CurrentTimeSlot: React.ForwardRefExoticComponent<CurrentTimeSlotProps & React.RefAttributes<HTMLElement>>;
+/**
+ * Headless component for current fulfillment options
+ * Provides access to pickup, delivery, and dine-in options
+ *
+ * @example
+ * ```tsx
+ * <Settings.CurrentFulfillment>
+ *   {({ fulfillment, availableOptions }) => (
+ *     <div>
+ *       <h3>Available Options:</h3>
+ *       {availableOptions.map(option => (
+ *         <div key={option}>
+ *           {option}: {fulfillment[option]?.enabled ? 'Available' : 'Unavailable'}
+ *           {fulfillment[option]?.estimatedTime && (
+ *             <span> - {fulfillment[option].estimatedTime} mins</span>
+ *           )}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   )}
+ * </Settings.CurrentFulfillment>
+ * ```
+ */
+interface CurrentLocationProps {
+    /** Whether to render as a child component */
+    asChild?: boolean;
+    /** CSS classes to apply to the default element */
+    className?: string;
+    /** Children render prop that receives the location data */
+    children?: AsChildChildren<{
+        currentLocation: {
+            name: string;
+        };
+        hasLocation: boolean;
+    }>;
+}
+/**
+ * Headless component for current location data
+ * Provides access to store location and coordinates
+ *
+ * @example
+ * ```tsx
+ * <Settings.CurrentLocation>
+ *   {({ location, hasLocation }) => (
+ *     <div>
+ *       <p>{currentLocation.name}</p>
+ *       {hasLocation && (
+ *         <p>Coordinates: {location.latitude}, {location.longitude}</p>
+ *       )}
+ *     </div>
+ *   )}
+ * </Settings.CurrentLocation>
+ * ```
+ */
+export declare const CurrentLocation: React.FC<CurrentLocationProps>;
+interface ExtraDataProps {
+    /** Children render prop that receives the extra settings data */
+    children: (props: {
+        extraData: {
+            acceptingOrders: boolean;
+            deliveryFee?: number;
+            minOrderAmount?: number;
+            freeDeliveryThreshold?: number;
+            taxRate?: number;
+            serviceCharge?: number;
+            isOnline?: boolean;
+            orderingDisabledReason?: string;
+        };
+        hasExtraData: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Headless component for extra settings data
+ * Provides access to ordering status, fees, and thresholds
+ *
+ * @example
+ * ```tsx
+ * <Settings.ExtraData>
+ *   {({ extraData, hasExtraData }) => (
+ *     hasExtraData ? (
+ *       <div>
+ *         <p>Status: {extraData.acceptingOrders ? 'Open' : 'Closed'}</p>
+ *         {extraData.orderingDisabledReason && (
+ *           <p>Reason: {extraData.orderingDisabledReason}</p>
+ *         )}
+ *         <p>Delivery Fee: ${extraData.deliveryFee}</p>
+ *         <p>Min Order: ${extraData.minOrderAmount}</p>
+ *         <p>Free Delivery: ${extraData.freeDeliveryThreshold}</p>
+ *         <p>Tax Rate: {extraData.taxRate}%</p>
+ *       </div>
+ *     ) : (
+ *       <div>No additional settings available</div>
+ *     )
+ *   )}
+ * </Settings.ExtraData>
+ * ```
+ */
+export declare const ExtraData: React.FC<ExtraDataProps>;
+export {};