import React from 'react';
import * as operationsSDK from '@wix/auto_sdk_restaurants_operations';
import { DispatchType, FulfillmentsServiceConfig, TimeSlot } from '../../types/fulfillments-types.js';
import * as fulfillemtMethodsSDK from '@wix/auto_sdk_restaurants_fulfillment-methods';
export interface RootProps {
    children: (props: {
        isLoading: boolean;
    }) => React.ReactNode;
    fulfillmentsServiceConfig?: FulfillmentsServiceConfig;
}
/**
 * Core Settings Root component that provides service context
 * Wraps children with both OLOSettingsService and FulfillmentsService providers
 *
 * Note: Use loadFulfillmentsServiceConfig from '@wix/headless-restaurants-olo/services'
 * to load the config before rendering this component.
 *
 * @example
 * ```tsx
 * import { loadFulfillmentsServiceConfig, OLOSettingsServiceDefinition } from '@wix/headless-restaurants-olo/services';
 *
 * // In your component:
 * const service = useService(OLOSettingsServiceDefinition);
 * const [config, setConfig] = useState(null);
 *
 * useEffect(() => {
 *   loadFulfillmentsServiceConfig(service.operation?.get()).then(setConfig);
 * }, []);
 *
 * if (!config) return <div>Loading...</div>;
 *
 * <Settings.Root fulfillmentsServiceConfig={config}>
 *   <Settings.CurrentTimeSlot>
 *     {({ timeSlot, hasDetails }) => (
 *       <div>{timeSlot?.dispatchType}</div>
 *     )}
 *   </Settings.CurrentTimeSlot>
 * </Settings.Root>
 * ```
 */
export declare const Root: React.FC<RootProps>;
export interface CurrentTimeSlotProps {
    children: (props: {
        timeSlot: TimeSlot;
        hasDetails: boolean;
        asapTime: number | undefined;
        asapTimeRange: operationsSDK.DurationRange | undefined;
    }) => React.ReactNode;
}
/**
 * Component that provides access to current time slot
 *
 * @example
 * ```tsx
 * <CoreSettings.CurrentTimeSlot>
 *   {({ timeSlot, hasDetails }) => (
 *     hasDetails ? (
 *       <div>
 *         <h3>{timeSlot.dispatchType}</h3>
 *       </div>
 *     ) : (
 *       <div>No time slot selected</div>
 *     )
 *   )}
 * </CoreSettings.CurrentTimeSlot>
 * ```
 */
export declare const CurrentTimeSlot: React.FC<CurrentTimeSlotProps>;
export interface CurrentFulfillmentProps {
    children: (props: {
        fulfillment: {
            current?: operationsSDK.TimeSlot;
        };
        hasFulfillment: boolean;
        availableOptions: string[];
    }) => React.ReactNode;
}
/**
 * Component that provides access to current fulfillment options
 *
 * @example
 * ```tsx
 * <CoreSettings.CurrentFulfillment>
 *   {({ fulfillment, availableOptions }) => (
 *     <div>
 *       <h3>Available Options:</h3>
 *       {availableOptions.map(option => (
 *         <div key={option}>{option}: Available</div>
 *       ))}
 *     </div>
 *   )}
 * </CoreSettings.CurrentFulfillment>
 * ```
 */
export declare const CurrentFulfillment: React.FC<CurrentFulfillmentProps>;
export interface CurrentLocationProps {
    children: (props: {
        location: {
            name: string;
        };
        hasLocation: boolean;
    }) => React.ReactNode;
}
/**
 * Component that provides access to current location data
 *
 * @example
 * ```tsx
 * <CoreSettings.CurrentLocation>
 *   {({ location, hasLocation }) => (
 *     <div>
 *       <p>{location.name}</p>
 *     </div>
 *   )}
 * </CoreSettings.CurrentLocation>
 * ```
 */
export declare const CurrentLocation: React.FC<CurrentLocationProps>;
export interface MinOrderAmountProps {
    children: (props: {
        minOrderAmount: number | undefined;
        hasMinOrderAmount: boolean;
    }) => React.ReactNode;
}
/**
 * Component that provides access to minimum order amount information
 *
 * @example
 * ```tsx
 * <CoreSettings.MinOrderAmount>
 *   {({ minOrderAmount, hasMinOrderAmount }) => (
 *     hasMinOrderAmount ? (
 *       <div>Minimum order: ${minOrderAmount}</div>
 *     ) : null
 *   )}
 * </CoreSettings.MinOrderAmount>
 * ```
 */
export declare const MinOrderAmount: React.FC<MinOrderAmountProps>;
export interface AcceptingOrdersProps {
    children: (props: {
        acceptingOrders: boolean;
    }) => React.ReactNode;
}
/**
 * Component that provides access to accepting orders status
 *
 * @example
 * ```tsx
 * <CoreSettings.AcceptingOrders>
 *   {({ acceptingOrders }) => (
 *     <div>
 *       Status: {acceptingOrders ? 'Accepting Orders' : 'Not Accepting Orders'}
 *     </div>
 *   )}
 * </CoreSettings.AcceptingOrders>
 * ```
 */
export declare const AcceptingOrders: React.FC<AcceptingOrdersProps>;
export interface DeliveryFeeProps {
    children: (props: {
        deliveryFee: string | undefined;
        hasDeliveryFee: boolean;
    }) => React.ReactNode;
}
/**
 * Component that provides access to delivery fee information
 *
 * @example
 * ```tsx
 * <CoreSettings.DeliveryFee>
 *   {({ deliveryFee, hasDeliveryFee }) => (
 *     hasDeliveryFee ? (
 *       <div>Delivery Fee: ${deliveryFee}</div>
 *     ) : (
 *       <div>Free Delivery</div>
 *     )
 *   )}
 * </CoreSettings.DeliveryFee>
 * ```
 */
export declare const DeliveryFee: React.FC<DeliveryFeeProps>;
export interface FreeDeliveryThresholdProps {
    children: (props: {
        freeDeliveryThreshold: string | undefined;
        hasFreeDeliveryThreshold: boolean;
    }) => React.ReactNode;
}
/**
 * Component that provides access to free delivery threshold information
 *
 * @example
 * ```tsx
 * <CoreSettings.FreeDeliveryThreshold>
 *   {({ freeDeliveryThreshold, hasFreeDeliveryThreshold }) => (
 *     hasFreeDeliveryThreshold ? (
 *       <div>Free delivery on orders over ${freeDeliveryThreshold}</div>
 *     ) : null
 *   )}
 * </CoreSettings.FreeDeliveryThreshold>
 * ```
 */
export declare const FreeDeliveryThreshold: React.FC<FreeDeliveryThresholdProps>;
export interface SelectedAddressProps {
    children: (props: {
        selectedAddress: fulfillemtMethodsSDK.CommonAddress | null;
        hasAddress: boolean;
        selectedType: DispatchType | null;
    }) => React.ReactNode;
}
/**
 * Component that provides access to the selected address
 *
 * @example
 * ```tsx
 * <CoreSettings.SelectedAddress>
 *   {({ address, hasAddress }) => (
 *     hasAddress ? (
 *       <div>
 *         <p>{address.street}</p>
 *         <p>{address.city}, {address.state} {address.zip}</p>
 *         <p>{address.country}</p>
 *       </div>
 *     ) : null
 *   )}
 * </CoreSettings.SelectedAddress>
 * ```
 */
export declare const SelectedAddress: React.FC<SelectedAddressProps>;
export interface DispatchTypeSelectorProps {
    children: (props: {
        availableTypes: Array<{
            type: DispatchType;
            isSelected: boolean;
            timeSlot: TimeSlot | null;
        }>;
        selectedType: DispatchType | null;
        selectDispatchType: (type: DispatchType) => void;
        hasTypes: boolean;
    }) => React.ReactNode;
}
/**
 * Component that provides dispatch type selection (pickup or delivery)
 *
 * @example
 * ```tsx
 * <CoreSettings.DispatchTypeSelector>
 *   {({ availableTypes, selectedType, selectDispatchType }) => (
 *     <div>
 *       {availableTypes.map(({ type, isSelected }) => (
 *         <button
 *           key={type}
 *           onClick={() => selectDispatchType(type)}
 *           disabled={isSelected}
 *         >
 *           {type} {isSelected && '(selected)'}
 *         </button>
 *       ))}
 *     </div>
 *   )}
 * </CoreSettings.DispatchTypeSelector>
 * ```
 */
export declare const DispatchTypeSelector: React.FC<DispatchTypeSelectorProps>;