@zappie/foundations 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,808 @@
+import * as react from 'react';
+import { KeyboardEvent as KeyboardEvent$1, ImgHTMLAttributes, ChangeEvent, ClipboardEvent } from 'react';
+import * as _zappie_sdk from '@zappie/sdk';
+import { CartLine, CartLineInput, CartIssue, CartFix, Quote, DeliveryAddress, Branch as Branch$1, MenuSchedule, CartFulfilment, OptionGroup as OptionGroup$1, Item, Money as Money$1, Choice as Choice$1, MoneyFormatOptions, PaymentMethodKind, Category, Menu, OpeningTime } from '@zappie/sdk';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { useCart } from '@zappie/sdk/react';
+import { P as PartProps, a as Presentation, S as SwipeDirection } from './engine-XTsgCwwe.js';
+import { C as CloseOptions, O as OverlayQuery } from './history-Bqu12Vkz.js';
+import '@base-ui/react/dialog';
+
+/** Account stubs that do not read credentials or host authentication. */
+type Customer = {
+    id: string;
+    givenName?: string;
+    phoneMasked: string;
+};
+/**
+ * Sign-in options reserved by the account contract.
+ * The current Account sign-in stub rejects with AccountNotConfiguredError.
+ */
+type SignInOptions = {
+    returnTo?: string;
+    prompt?: "none" | "login";
+    display?: "popup" | "redirect" | "auto";
+    scopes?: ("openid" | "phone" | "profile" | "addresses" | "orders:read" | "offline_access" | "cart")[];
+};
+/**
+ * An error from Account sign-in and sign-out when authentication is not configured.
+ */
+declare class AccountNotConfiguredError extends Error {
+    readonly code = "not_configured";
+    constructor();
+}
+declare function signIn(_options?: SignInOptions): Promise<void>;
+declare function signOut(_options?: {
+    everywhere?: boolean;
+}): Promise<void>;
+/**
+ * Account UI stubs that expose a not_configured status and a null customer.
+ * SignIn and SignOut reject with AccountNotConfiguredError. They do not authenticate.
+ */
+declare const Account: {
+    SignIn: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            signIn: typeof signIn;
+            status: "not_configured";
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    SignOut: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            signOut: typeof signOut;
+            status: "not_configured";
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Customer: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            customer: Customer | null;
+            status: "not_configured";
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * The current quantity, bounds, step, disabled state and value setter exposed by a quantity control.
+ */
+type QuantityState = {
+    value: number;
+    setValue: (value: number) => void;
+    min: number;
+    max: number;
+    step: number;
+    disabled: boolean;
+};
+/**
+ * Controlled or default quantity, bounds and change callback for Quantity.Root.
+ */
+type QuantityProps = PartProps<QuantityState> & {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+};
+declare function Root$5({ value, defaultValue, onValueChange, min, max, step, disabled, ...props }: QuantityProps): react_jsx_runtime.JSX.Element;
+/**
+ * Composable quantity controls with bounded step changes and keyboard support.
+ * Wrap Value, Increment and Decrement in Quantity.Root.
+ *
+ * @example
+ * ```tsx
+ * <Quantity.Root min={1} max={10} defaultValue={1}>
+ *   <Quantity.Decrement>Less</Quantity.Decrement>
+ *   <Quantity.Value aria-label="Quantity" />
+ *   <Quantity.Increment>More</Quantity.Increment>
+ * </Quantity.Root>
+ * ```
+ */
+declare const Quantity: {
+    Root: typeof Root$5;
+    Value: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: QuantityState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Increment: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: QuantityState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Decrement: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: QuantityState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+type CartContext = ReturnType<typeof useCart>;
+declare function Root$4(props: PartProps<CartContext>): react_jsx_runtime.JSX.Element;
+type LineContext = {
+    line: CartLine;
+    item: _zappie_sdk.Item | undefined;
+    edit: (patch: Partial<Omit<CartLineInput, "itemId">>) => CartLine;
+    remove: () => void;
+};
+declare function CartQuantity({ lineId, ...props }: Omit<QuantityProps, "value" | "defaultValue" | "onValueChange"> & {
+    lineId: string;
+}): react_jsx_runtime.JSX.Element | null;
+/**
+ * Composable cart parts for lines, quantity changes, removal, empty state and validation issues.
+ * Wrap the parts in Cart.Root inside your ZappieProvider.
+ */
+declare const Cart: {
+    Root: typeof Root$4;
+    Line: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: LineContext) => react.ReactNode);
+    } & {
+        line: CartLine;
+    } & react.RefAttributes<HTMLElement>>;
+    Quantity: typeof CartQuantity;
+    Remove: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: Record<string, never>) => react.ReactNode);
+    } & {
+        lineId: string;
+    } & react.RefAttributes<HTMLElement>>;
+    Empty: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: Record<string, never>) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Issues: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            issues: readonly CartIssue[];
+            applyFix: (issue: CartIssue, fix?: CartFix) => void;
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+};
+/**
+ * The quote and its display status: loading, stale, ready or offline.
+ */
+type TotalsState = {
+    quote?: Quote | undefined;
+    status: "loading" | "stale" | "ready" | "offline";
+};
+/**
+ * Expose the cart quote and its freshness or network status to your render function.
+ * Subscribes to the cart and quote failures through your ZappieProvider.
+ */
+declare const Totals: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+    asChild?: boolean;
+    children?: react.ReactNode | ((state: TotalsState) => react.ReactNode);
+} & react.RefAttributes<HTMLElement>>;
+
+declare function useCombobox<T>(results: readonly T[], onSelect: (item: T) => void): {
+    setListId: react.Dispatch<react.SetStateAction<string>>;
+    registerOption: (index: number, id: string) => void;
+    activeIndex: number;
+    setActiveIndex: react.Dispatch<react.SetStateAction<number>>;
+    isOpen: boolean;
+    setOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    select: (index: number) => void;
+    inputProps: {
+        role: string;
+        "aria-autocomplete": "list";
+        "aria-expanded": boolean;
+        "aria-controls": string;
+        "aria-activedescendant": string | undefined;
+        onKeyDown: (event: KeyboardEvent$1) => void;
+        onFocus: () => void;
+    };
+    listProps: {
+        id: string;
+        role: string;
+        hidden: boolean;
+    };
+    getOptionProps: (index: number) => {
+        id: string;
+        role: string;
+        "aria-selected": boolean;
+        "data-selected": string | undefined;
+        onMouseDown: (event: {
+            preventDefault: () => void;
+        }) => void;
+        onPointerDown: (event: {
+            stopPropagation: () => void;
+        }) => void;
+        onTouchStart: (event: {
+            stopPropagation: () => void;
+        }) => void;
+        onClick: () => void;
+    };
+};
+
+/**
+ * A labelled address suggestion with an ID and the delivery address selected by the shopper.
+ */
+type AddressSuggestion = {
+    id: string;
+    label: string;
+    address: DeliveryAddress;
+};
+/**
+ * Address picker state with query controls, combobox navigation, suggestions and request status.
+ */
+type AddressState = ReturnType<typeof useCombobox<AddressSuggestion>> & {
+    query: string;
+    setQuery: (query: string) => void;
+    suggestions: AddressSuggestion[];
+    status: "loading" | "ready" | "error";
+    error?: unknown;
+};
+declare function Picker({ getSuggestions, onSelect, query, defaultQuery, onQueryChange, debounceMs, announcement, ...props }: PartProps<AddressState> & {
+    /** Screen-reader text for the suggestion count. Override it for your language. */
+    announcement?: (count: number) => string;
+    getSuggestions: (query: string, signal?: AbortSignal) => Promise<AddressSuggestion[]>;
+    onSelect: (suggestion: AddressSuggestion) => void;
+    query?: string;
+    defaultQuery?: string;
+    onQueryChange?: (query: string) => void;
+    debounceMs?: number;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Composable address picker parts with debounced suggestions and keyboard navigation.
+ * Supply getSuggestions and onSelect to Address.Picker. It cancels outdated requests.
+ */
+declare const Address: {
+    Picker: typeof Picker;
+    Input: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: AddressState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Suggestions: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: AddressState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Suggestion: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: AddressState) => react.ReactNode);
+    } & {
+        index: number;
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+type BranchPickerState = {
+    branches: Branch$1[];
+    selected?: Branch$1 | undefined;
+    isOpenNow: (branch: Branch$1) => boolean;
+    select: (branch: Branch$1) => Promise<void>;
+    isLoading: boolean;
+    error?: unknown;
+};
+/**
+ * A branch picker that moves the cart to a selected branch and exposes loading and error state.
+ * Use Branch.Picker within your ZappieProvider.
+ */
+declare const Branch: {
+    Picker: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: BranchPickerState) => react.ReactNode);
+    } & {
+        branches: Branch$1[];
+        value?: string;
+        onSelect?: (branch: Branch$1) => void;
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * A selectable time with an ISO instant, local date and display label including the UTC offset.
+ */
+type ScheduleSlot = {
+    value: string;
+    label: string;
+    date: string;
+};
+/**
+ * Available days and slots, the selected time and controls for choosing ASAP or a scheduled time.
+ */
+type ScheduleState = {
+    days: {
+        date: string;
+        slots: ScheduleSlot[];
+    }[];
+    slots: ScheduleSlot[];
+    value: string | null;
+    setValue: (value: string | null) => void;
+    isAsap: boolean;
+    canAsap: boolean;
+    isValid: boolean;
+};
+/**
+ * Generate scheduling slots within branch hours and any supplied menu hours and preorder limits.
+ * Returns no slots when the branch does not support scheduling.
+ *
+ * @param branch - The branch whose hours and scheduling capability apply.
+ * @param timezone - The time zone used to interpret opening hours and label slots.
+ * @param now - The instant from which notice and scheduling limits are measured.
+ * @returns Slots with ISO values, local dates and display labels.
+ */
+declare function scheduleSlots(branch: Branch$1, timezone: string, now: Date, { intervalMinutes, maxDays, noticeMinutes, menuSchedule, }?: {
+    intervalMinutes?: number | undefined;
+    maxDays?: number | undefined;
+    noticeMinutes?: number | undefined;
+    menuSchedule?: MenuSchedule | undefined;
+}): ScheduleSlot[];
+/**
+ * Expose valid fulfilment slots and ASAP eligibility using branch hours and loaded menu metadata.
+ * Use null for ASAP. Requires a ZappieProvider and refreshes the available times each minute.
+ */
+declare const Schedule: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+    asChild?: boolean;
+    children?: react.ReactNode | ((state: ScheduleState) => react.ReactNode);
+} & {
+    branch: Branch$1;
+    timezone?: string;
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null) => void;
+    intervalMinutes?: number | undefined;
+    maxDays?: number | undefined;
+    noticeMinutes?: number;
+} & react.RefAttributes<HTMLElement>>;
+
+type FulfilmentState = {
+    options: CartFulfilment["type"][];
+    value: CartFulfilment | null;
+    setValue: (value: CartFulfilment) => void;
+};
+/**
+ * A fulfilment switch that exposes the active branch modes and updates the SDK cart.
+ * Selections must use an offered mode and the active branch ID.
+ */
+declare const Fulfilment: {
+    Switch: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: FulfilmentState) => react.ReactNode);
+    } & {
+        value?: CartFulfilment | null;
+        defaultValue?: CartFulfilment | null;
+        onValueChange?: (value: CartFulfilment | null) => void;
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * Manage either a supplied value or internal state initialized from defaultValue.
+ * The setter accepts a value or updater and calls onChange only when Object.is detects a change.
+ *
+ * @returns The current value and a stable setter. A defined value keeps state controlled by you.
+ */
+declare function useControllableState<T>({ value, defaultValue, onChange, }: {
+    value?: T | undefined;
+    defaultValue: T;
+    onChange?: ((value: T) => void) | undefined;
+}): readonly [T, (next: T | ((previous: T) => T)) => void];
+
+/**
+ * An SDK option group with the effective rules exposed by the item preview.
+ */
+type ActiveGroup = OptionGroup$1;
+/**
+ * The current item selection, preview prices, validation issues and actions supplied to item form parts.
+ */
+type ItemFormContext = {
+    item: Item;
+    groups: ActiveGroup[];
+    quantity: number;
+    setQuantity: (quantity: number) => void;
+    unitPrice: Money$1;
+    total: Money$1;
+    issues: CartIssue[];
+    canAdd: boolean;
+    add: () => CartLine | null;
+    status: "incomplete" | "valid" | "added";
+    value: CartLineInput;
+    setValue: (value: CartLineInput) => void;
+};
+/**
+ * Item form configuration with controlled or default selections and cart commit callbacks.
+ * Supply onCommit to update an existing line instead of adding a new one.
+ */
+type ItemFormProps = PartProps<ItemFormContext> & {
+    item: Item;
+    value?: CartLineInput;
+    defaultValue?: Partial<CartLineInput>;
+    onValueChange?: (value: CartLineInput) => void;
+    defaultQuantity?: number;
+    onAdded?: (line: CartLine) => void;
+    /** Update an existing line through the same validation and focus workflow. */
+    onCommit?: (input: CartLineInput) => CartLine;
+};
+declare function Root$3({ item, value, defaultValue, onValueChange, defaultQuantity, onAdded, onCommit, ...props }: ItemFormProps): react_jsx_runtime.JSX.Element;
+
+type GroupState = {
+    group: OptionGroup$1;
+    selected: string[];
+    invalid: boolean;
+    input: string;
+    setInput: (value: string) => void;
+    toggle: (id: string) => void;
+    quantities: Readonly<Record<string, number>>;
+    /** Set a choice's quantity within its bounds. Zero deselects it. A positive value selects it. */
+    setQuantity: (id: string, quantity: number) => void;
+};
+type ChoiceState = {
+    choice: Choice$1;
+    selected: boolean;
+    disabled: boolean;
+    toggle: () => void;
+    /** Selected quantity (0 when unselected) and the choice's bounds. */
+    quantity: number;
+    min: number;
+    max: number;
+    setQuantity: (quantity: number) => void;
+};
+/**
+ * Render a selectable option within an OptionGroup, with radio or checkbox semantics.
+ * Exposes selection and quantity controls and disables unavailable choices.
+ */
+declare const Choice: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+    asChild?: boolean;
+    children?: react.ReactNode | ((state: ChoiceState) => react.ReactNode);
+} & {
+    choice: Choice$1;
+} & react.RefAttributes<HTMLElement>>;
+/**
+ * Group item options with selection rules, validation state and an Input part for typed responses.
+ * Use within ItemForm.Root. Use Choice for options and OptionGroup.Input for typed responses.
+ */
+declare const OptionGroup: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+    asChild?: boolean;
+    children?: react.ReactNode | ((state: GroupState) => react.ReactNode);
+} & {
+    group: OptionGroup$1;
+} & react.RefAttributes<HTMLElement>> & {
+    Input: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: GroupState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * Composable item configuration parts for selecting options, validating a line and adding it to the cart.
+ * Use ItemForm.Root within your ZappieProvider and place Options and Add inside it.
+ */
+declare const ItemForm: {
+    Root: typeof Root$3;
+    Options: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: ItemFormContext) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Add: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: ItemFormContext) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/** Props for a responsive storefront image. */
+type ImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "src" | "srcSet"> & {
+    src: string;
+    alt: string;
+    sizes?: string;
+    priority?: boolean;
+    quality?: number;
+    mode?: "resize" | "direct";
+};
+/** Render an image through same-origin resizing, or directly when unavailable. */
+declare function Image({ src, sizes, priority, quality, mode, alt, ...props }: ImageProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Render formatted SDK money in a data element, with the minor-unit amount as its value.
+ * You can override the content with children or a render function receiving the formatted string.
+ */
+declare const Money: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+    asChild?: boolean;
+    children?: react.ReactNode | ((state: {
+        formatted: string;
+    }) => react.ReactNode);
+} & {
+    value: Money$1;
+    formatOptions?: MoneyFormatOptions;
+} & react.RefAttributes<HTMLElement>>;
+
+type OtpState = {
+    value: string;
+    slots: string[];
+    getSlotProps: (index: number) => ReturnType<typeof slotAttributes>;
+};
+declare function slotAttributes(index: number, length: number, value: string, disabled: boolean, update: (index: number, text: string) => void, focus: (index: number) => void): {
+    type: string;
+    inputMode: "numeric";
+    autoComplete: string;
+    "aria-label": string;
+    "data-otp-slot": number;
+    value: string;
+    disabled: boolean;
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    onPaste: (event: ClipboardEvent<HTMLInputElement>) => void;
+    onKeyDown: (event: KeyboardEvent$1<HTMLInputElement>) => void;
+    onFocus: (event: {
+        currentTarget: HTMLInputElement;
+    }) => void;
+};
+/**
+ * A numeric one-time-code input with paste, autofill and keyboard focus handling.
+ * Otp.Input defaults to six digits and calls onComplete when a new complete code is entered.
+ * You supply code verification.
+ */
+declare const Otp: {
+    Input: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: OtpState) => react.ReactNode);
+    } & {
+        length?: number;
+        value?: string;
+        defaultValue?: string;
+        onValueChange?: (value: string) => void;
+        onComplete?: (value: string) => void;
+        disabled?: boolean;
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * Control an overlay whose open state is stored in a URL query parameter.
+ *
+ * @param param - The query parameter to read and update.
+ * @param id - The value that identifies this overlay as open.
+ * @param options - Fallback query values and query parameters to omit when closing.
+ * @returns Reactive open state and history-backed open and close actions.
+ */
+declare function useOverlay(param: string, id: string, options?: CloseOptions): {
+    isOpen: boolean;
+    open: (query?: OverlayQuery) => void;
+    close: () => void;
+};
+/** Tailwind's default min-width breakpoints. */
+declare const BREAKPOINTS: {
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+};
+type ResponsivePresentation = Presentation | ({
+    base: Presentation;
+} & Partial<Record<keyof typeof BREAKPOINTS, Presentation>>);
+type OverlayState = ReturnType<typeof useOverlay>;
+/**
+ * The URL is the only open state. The engine (Base UI) supplies the modal mechanics: portal,
+ * focus scope, scroll lock, outside and Escape dismissal, exit presence and, for drawers and
+ * sheets, swipe-to-dismiss. Every open or close it requests goes through the history core.
+ */
+declare function Root$2({ param, id, presentation, swipeDirection, fallback, omitParams, navigation, ...props }: PartProps<OverlayState> & {
+    param: string;
+    id: string;
+    /** Your URL adapter for overlays whose open state lives in the path. */
+    navigation?: OverlayState;
+    /** A `dialog`, swipeable `drawer` or `sheet`. Use `{ base, sm, md, lg, xl }` for responsive layouts. */
+    presentation?: ResponsivePresentation;
+    /** Swipe direction to dismiss. Defaults to `down` for drawers and `right` for sheets. */
+    swipeDirection?: SwipeDirection;
+} & CloseOptions): react_jsx_runtime.JSX.Element;
+/**
+ * Composable dialog, drawer and sheet parts with URL-backed open state and a lazy modal engine.
+ * Use Root, Trigger, Content, Title and Close to connect history, focus handling and dismissal.
+ */
+declare const Overlay: {
+    Root: typeof Root$2;
+    Trigger: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            isOpen: boolean;
+            open: (query?: OverlayQuery) => void;
+            close: () => void;
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Content: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            isOpen: boolean;
+            open: (query?: OverlayQuery) => void;
+            close: () => void;
+        }) => react.ReactNode);
+    } & {
+        /** Runs on Escape. Call `event.preventDefault()` to keep the overlay open. */
+        onEscape?: (event: KeyboardEvent) => void;
+        /** Runs on an outside pointer press or focus. Call `event.preventDefault()` to keep the overlay open. */
+        onInteractOutside?: (event: Event) => void;
+        /** Keep the content mounted while closed, for exit animations driven by `data-state`. */
+        forceMount?: true;
+        /** Where to mount the content. Defaults to `document.body`. */
+        container?: HTMLElement | null;
+    } & react.RefAttributes<HTMLElement>>;
+    Title: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            isOpen: boolean;
+            open: (query?: OverlayQuery) => void;
+            close: () => void;
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Close: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: {
+            isOpen: boolean;
+            open: (query?: OverlayQuery) => void;
+            close: () => void;
+        }) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * A payment-method choice with optional disabled state and an explanatory reason.
+ */
+type PaymentMethod = {
+    value: PaymentMethodKind;
+    disabled?: boolean;
+    reason?: string;
+};
+type PaymentState = {
+    methods: PaymentMethod[];
+    value: PaymentMethodKind | null;
+    setValue: (value: PaymentMethodKind) => void;
+};
+declare function Root$1({ methods, value, defaultValue, onValueChange, ...props }: PartProps<PaymentState> & {
+    methods: (PaymentMethod | PaymentMethodKind)[];
+    value?: PaymentMethodKind | null;
+    defaultValue?: PaymentMethodKind | null;
+    onValueChange?: (value: PaymentMethodKind | null) => void;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Composable payment-method radio controls with keyboard navigation.
+ * Root manages the selection. Item renders each method and prevents selection when disabled.
+ */
+declare const PaymentMethods: {
+    Root: typeof Root$1;
+    Item: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: PaymentMethod & {
+            selected: boolean;
+        }) => react.ReactNode);
+    } & {
+        value: PaymentMethodKind;
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * A scored item or category returned by menu search, ordered by descending score.
+ */
+type SearchResult = {
+    type: "item";
+    item: Item;
+    score: number;
+} | {
+    type: "category";
+    category: Category;
+    score: number;
+};
+/**
+ * Index item names, tags and descriptions plus category names and descriptions for local search.
+ * Matches case- and accent-insensitive prefixes and allows a single edit for query tokens of at least four characters.
+ *
+ * @param menu - The menu snapshot you want to search.
+ * @returns A search function that requires every query token to match and sorts results by descending score.
+ */
+declare function createSearchIndex(menu: Menu): (query: string) => SearchResult[];
+
+/**
+ * Search query, results and combobox navigation exposed to search parts and render functions.
+ */
+type SearchState = ReturnType<typeof useCombobox<SearchResult>> & {
+    query: string;
+    setQuery: (query: string) => void;
+    results: SearchResult[];
+    setComposing: (value: boolean) => void;
+    error?: string;
+    retry?: () => void;
+};
+/**
+ * Externally supplied search results and optional loading, error, retry and composition controls.
+ */
+type SearchSource = {
+    results: SearchResult[];
+    isLoading?: boolean;
+    isStale?: boolean;
+    error?: string;
+    retry?: () => void;
+    onCompositionChange?: (composing: boolean) => void;
+};
+type RootProps = Omit<PartProps<SearchState>, "onSelect"> & {
+    announcement?: (count: number) => string;
+    query?: string;
+    defaultQuery?: string;
+    onQueryChange?: (query: string) => void;
+    onSelect?: (result: SearchResult) => void;
+    source?: SearchSource;
+};
+declare function Root(props: RootProps): react_jsx_runtime.JSX.Element;
+/**
+ * Composable menu search parts with combobox navigation and result announcements.
+ * Use Root with your own source or let it index the active branch menu through your ZappieProvider.
+ */
+declare const Search: {
+    Root: typeof Root;
+    Input: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: SearchState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Results: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: SearchState) => react.ReactNode);
+    } & react.RefAttributes<HTMLElement>>;
+    Result: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+        asChild?: boolean;
+        children?: react.ReactNode | ((state: SearchState) => react.ReactNode);
+    } & {
+        index: number;
+    } & react.RefAttributes<HTMLElement>>;
+};
+
+/**
+ * Parse a zero-padded HH:mm or HH:mm:ss wall-clock value without applying a time zone.
+ *
+ * @returns Clock parts with 12-hour and 24-hour values, or undefined for an invalid time.
+ * @example
+ * ```ts
+ * parseWallClock("14:30"); // { hour24: 14, hour12: 2, minute: 30, second: 0, period: "PM" }
+ * ```
+ */
+declare function parseWallClock(value: string): {
+    hour24: number;
+    hour12: number;
+    minute: number;
+    second: number;
+    period: string;
+} | undefined;
+/**
+ * Format a valid wall-clock time as a 12-hour label with AM or PM.
+ * Omits zero minutes and all seconds. Returns invalid input unchanged.
+ *
+ * @example
+ * ```ts
+ * formatWallClock("14:00"); // "2 PM"
+ * formatWallClock("09:30:15"); // "9:30 AM"
+ * ```
+ */
+declare function formatWallClock(value: string): string;
+/**
+ * Group consecutive days with identical opening intervals into display labels.
+ * Skips disabled intervals and days with no enabled hours, and orders the groups from Sunday to Saturday.
+ */
+declare function formatOpeningHours(times: OpeningTime[]): {
+    days: number[];
+    dayLabel: string;
+    hoursLabel: string;
+}[];
+type OpenStatusState = {
+    isOpen: boolean;
+    label: string;
+    nextChange?: Date;
+};
+/**
+ * Calculate whether a branch is open and provide its next opening or closing label.
+ * Accounts for weekly hours, special hours, overnight intervals and closedUntil.
+ *
+ * @param branch - The branch whose opening rules apply.
+ * @param timezone - The time zone used to interpret and display its hours.
+ * @param now - The instant to check. Defaults to the current time.
+ * @returns Open state, a display label and the next boundary found in the opening-hours window.
+ */
+declare function getOpenStatus(branch: Branch$1, timezone: string, now?: Date): OpenStatusState;
+
+/**
+ * Expose a branch opening label and open/closed state in a span or your render function.
+ * Uses your time zone override, then the branch, store or UTC, and refreshes at boundaries and window focus.
+ */
+declare const OpenStatus: react.ForwardRefExoticComponent<Omit<react.AllHTMLAttributes<HTMLElement>, "children" | "defaultValue" | "value"> & {
+    asChild?: boolean;
+    children?: react.ReactNode | ((state: OpenStatusState) => react.ReactNode);
+} & {
+    branch: Branch$1;
+    timezone?: string;
+} & react.RefAttributes<HTMLElement>>;
+
+/** The installed @zappie/foundations version. */
+declare const FOUNDATIONS_VERSION: string;
+
+export { Account, AccountNotConfiguredError, type ActiveGroup, Address, type AddressState, type AddressSuggestion, Branch, Cart, Choice, type Customer, FOUNDATIONS_VERSION, Fulfilment, Image, type ImageProps, ItemForm, type ItemFormContext, type ItemFormProps, Money, OpenStatus, OptionGroup, Otp, Overlay, PartProps, type PaymentMethod, PaymentMethods, Quantity, type QuantityProps, type QuantityState, Schedule, type ScheduleSlot, type ScheduleState, Search, type SearchResult, type SearchSource, type SearchState, type SignInOptions, Totals, type TotalsState, createSearchIndex, formatOpeningHours, formatWallClock, getOpenStatus, parseWallClock, scheduleSlots, useControllableState, useOverlay };