import React from 'react';
import { DispatchType, FulfillmentsServiceConfig } from '../types/fulfillments-types.js';
import { AsChildChildren } from '@wix/headless-utils/react';
/**
 * Props for the Settings Root component
 */
export interface RootProps {
    /** Child components that will have access to the settings context */
    children: (props: {
        isLoading: boolean;
    }) => React.ReactNode;
    /** Optional pre-loaded fulfillments service configuration */
    fulfillmentsServiceConfig?: FulfillmentsServiceConfig;
}
/**
 * Root headless component for OLO Settings
 * Provides service context for settings components
 *
 * @example
 * ```tsx
 * <Settings.Root fulfillmentsServiceConfig={config}>
 *   <Settings.CurrentTimeSlot>
 *     {({ timeSlot, hasDetails }) => (
 *       <div>{timeSlot?.dispatchType}</div>
 *     )}
 *   </Settings.CurrentTimeSlot>
 * </Settings.Root>
 * ```
 */
export declare const Root: React.FC<RootProps>;
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;
    /** prefixElement to display before the time slot text */
    prefixElement?: React.ReactNode;
    deliveryTypeText: string;
    pickupTypeText: string;
    asapTimeText: string;
    asapTimeRangeText: string;
    preorderTodayText: string;
    preorderTomorrowText: string;
}
export declare const CurrentTimeSlot: React.ForwardRefExoticComponent<CurrentTimeSlotProps & React.RefAttributes<HTMLElement>>;
interface DispatchTypeSelectorProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    /** Child components that will have access to dispatch type context */
    children: React.ReactNode;
}
/**
 * Container component for dispatch type selection (pickup or delivery)
 * Provides context for child components to access dispatch type data
 * Does not render if no dispatch types are available
 *
 * @example
 * ```tsx
 * <Settings.DispatchTypeSelector>
 *   <Settings.DispatchTypeOptions emptyState={<div>No options</div>}>
 *     <Settings.DispatchTypeOptionRepeater>
 *       {({ type, isSelected, selectDispatchType }) => (
 *         <button onClick={() => selectDispatchType(type)}>
 *           {type} {isSelected && '✓'}
 *         </button>
 *       )}
 *     </Settings.DispatchTypeOptionRepeater>
 *   </Settings.DispatchTypeOptions>
 * </Settings.DispatchTypeSelector>
 * ```
 */
export declare const DispatchTypeSelector: React.ForwardRefExoticComponent<DispatchTypeSelectorProps & React.RefAttributes<HTMLDivElement>>;
interface DispatchTypeOptionsProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    /** Child components to render when dispatch types are available */
    children: React.ReactNode;
    /** Optional content to display when no dispatch types are available */
    emptyState?: React.ReactNode;
}
/**
 * Container for dispatch type options list with empty state support
 *
 * @example
 * ```tsx
 * <Settings.DispatchTypeOptions emptyState={<div>No options available</div>}>
 *   <Settings.DispatchTypeOptionRepeater>
 *     {({ type }) => <div>{type}</div>}
 *   </Settings.DispatchTypeOptionRepeater>
 * </Settings.DispatchTypeOptions>
 * ```
 */
export declare const DispatchTypeOptions: React.ForwardRefExoticComponent<DispatchTypeOptionsProps & React.RefAttributes<HTMLDivElement>>;
interface DispatchTypeOptionRepeaterProps {
    /** Render prop that receives each dispatch type option data */
    children: (props: {
        type: DispatchType;
        isSelected: boolean;
        selectDispatchType: (type: DispatchType) => void;
    }) => React.ReactNode;
}
/**
 * Repeater component that renders children for each available dispatch type
 *
 * @example
 * ```tsx
 * <Settings.DispatchTypeOptionRepeater>
 *   {({ type, isSelected, selectDispatchType }) => (
 *     <button
 *       onClick={() => selectDispatchType(type)}
 *       data-selected={isSelected}
 *     >
 *       {type}
 *     </button>
 *   )}
 * </Settings.DispatchTypeOptionRepeater>
 * ```
 */
export declare const DispatchTypeOptionRepeater: React.FC<DispatchTypeOptionRepeaterProps>;
/**
 * 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 MinOrderAmountProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    asChild?: boolean;
    /** Label text to display before the minimum order amount (e.g., "Min Order:") */
    label?: string;
    /** Children render prop that receives the minimum order amount data */
    children?: AsChildChildren<{
        minOrderAmount: number | undefined;
        hasMinOrderAmount: boolean;
    }> | React.ReactNode;
}
/**
 * Headless component for minimum order amount information
 *
 * @example
 * ```tsx
 * <Settings.MinOrderAmount>
 *   {({ minOrderAmount, hasMinOrderAmount }) => (
 *     hasMinOrderAmount ? (
 *       <div>Minimum order: ${minOrderAmount}</div>
 *     ) : null
 *   )}
 * </Settings.MinOrderAmount>
 * ```
 */
export declare const MinOrderAmount: React.FC<MinOrderAmountProps>;
interface AcceptingOrdersProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    asChild?: boolean;
    /** Children render prop that receives the accepting orders status */
    children?: AsChildChildren<{
        acceptingOrders: boolean;
    }> | React.ReactNode;
}
/**
 * Headless component for accepting orders status
 *
 * @example
 * ```tsx
 * <Settings.AcceptingOrders>
 *   {({ acceptingOrders }) => (
 *     <div>
 *       Status: {acceptingOrders ? 'Accepting Orders' : 'Not Accepting Orders'}
 *     </div>
 *   )}
 * </Settings.AcceptingOrders>
 * ```
 */
export declare const AcceptingOrders: React.FC<AcceptingOrdersProps>;
interface SelectedAddressProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    asChild?: boolean;
    /** Children render prop that receives the selected address data */
    children?: AsChildChildren<{
        formattedAddress: string | null;
        selectedType: DispatchType | null;
        hasAddress: boolean;
    }> | React.ReactNode;
}
/**
 * Headless component for selected address information
 *
 * @example
 * ```tsx
 * <Settings.SelectedAddress>
 *   {({ formattedAddress, selectedType, hasAddress }) => (
 *     <div>
 *       <p>{formattedAddress}</p>
 *       <p>{selectedType}</p>
 *     </div>
 *   )}
 * </Settings.SelectedAddress>
 * ```
 */
export declare const SelectedAddress: React.FC<SelectedAddressProps>;
interface DeliveryFeeProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    asChild?: boolean;
    /** Label text to display before the delivery fee (e.g., "Delivery Fee:") */
    label?: string;
    /** Children render prop that receives the delivery fee data */
    children?: AsChildChildren<{
        deliveryFee: string | undefined;
        hasDeliveryFee: boolean;
    }> | React.ReactNode;
}
/**
 * Headless component for delivery fee information
 *
 * @example
 * ```tsx
 * <Settings.DeliveryFee>
 *   {({ deliveryFee, hasDeliveryFee }) => (
 *     hasDeliveryFee ? (
 *       <div>Delivery Fee: ${deliveryFee}</div>
 *     ) : (
 *       <div>Free Delivery</div>
 *     )
 *   )}
 * </Settings.DeliveryFee>
 * ```
 */
export declare const DeliveryFee: React.FC<DeliveryFeeProps>;
interface FreeDeliveryThresholdProps extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'> {
    asChild?: boolean;
    /** Label text to display before the free delivery threshold (e.g., "Free delivery above:") */
    label?: string;
    /** Children render prop that receives the free delivery threshold data */
    children?: AsChildChildren<{
        freeDeliveryThreshold: string | undefined;
        hasFreeDeliveryThreshold: boolean;
    }> | React.ReactNode;
}
/**
 * Headless component for free delivery threshold information
 *
 * @example
 * ```tsx
 * <Settings.FreeDeliveryThreshold>
 *   {({ freeDeliveryThreshold, hasFreeDeliveryThreshold }) => (
 *     hasFreeDeliveryThreshold ? (
 *       <div>Free delivery on orders over ${freeDeliveryThreshold}</div>
 *     ) : null
 *   )}
 * </Settings.FreeDeliveryThreshold>
 * ```
 */
export declare const FreeDeliveryThreshold: React.FC<FreeDeliveryThresholdProps>;
export {};