import * as React$1 from 'react';
import React__default, { ReactNode, PointerEvent, MouseEvent } from 'react';
import { d as AdSlot, c as AdPosition, a as AdContextValue, S as SignInOptions } from './sign-in-DQlIdqsi.mjs';
export { A as AdConfig, g as getVariantDisplayName } from './sign-in-DQlIdqsi.mjs';
import { C as CimplifyClient, aj as EnrichedOrderItem, ai as EnrichedOrder, u as Business, aN as Location, bQ as ReorderResult, be as OrderStatus, aV as Order, bC as QuoteBundleSelectionInput, bD as QuoteCompositeSelectionInput, bs as PriceQuote, bG as QuoteUiMessage, c8 as Service, p as AvailableSlot, a8 as DayAvailability, a5 as CustomerBooking, F as CancelBookingResult, h as ActivityStateResponse, ci as SessionMessage, A as ActivityRecommendation, aa as DeliveryFeeResponse, ae as DeliveryOptionsResponse, aw as FxRateResponse, cs as StoreCreditBalance, cu as StorefrontBootstrap, W as ChatWidgetStarter, T as ChatMessage, V as ChatUploadAttachment, a1 as CimplifyElements, O as ChatAttachment, aG as LineItem, cm as Staff, c2 as Room, U as ChatReplyContext } from './catalogue-OT89_Ifs.mjs';
import { j as CheckoutTermsView, cR as OrderType, dL as ProcessCheckoutResult, aY as CheckoutStatus, aZ as CheckoutStatusContext, C as CurrencyCode, P as Product, de as Pagination, c as CimplifyError, e as ProductWithDetails, b as Category, cJ as Money, a as ChosenPrice, a3 as BundleSelectionInput, b8 as ComponentSelectionInput, a2 as BundleSelectionData, bh as CompositeSelectionData, d as Collection, dU as ProductTaxonomy, eL as TaxonomyWithChildren, dV as ProductTimeProfile, bz as Deal, dQ as ProductDealInfo, bJ as DiscountValidation, a5 as BundleSummary, bf as CompositePriceResult, eG as SubscriptionWithDetails, eF as SubscriptionStatus, eC as Subscription, bn as CustomAttributeDefinition, dZ as PropertyFacet, dP as ProductBillingPlan, f3 as VariantView, eZ as VariantAxisWithValues, y as AddressInfo, L as AuthenticatedData, c5 as ElementsOptions, dp as PaymentMethodInfo, c3 as ElementsCheckoutResult, dK as ProcessCheckoutOptions, u as AddOnWithOptions, $ as BundleComponentView, a0 as BundlePriceType, bd as CompositeGroupView, bM as DisplayCart, dR as ProductInputField, z as AddressValue, S as SaleInfo, U as UpcomingSale, D as DurationUnit, W as BoundaryKind, et as SchedulingMode, bB as DepositType, bo as CustomAttributeValue, dS as ProductProperty, ei as QuantityPricingTier } from './elements-Bty6Qs_N.mjs';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { P as ProductWithPrice } from './price-CSztR02F.mjs';
import { ClassValue } from 'clsx';
import { Matcher } from 'react-day-picker';

interface UserIdentity {
    uid: string;
    isAuthenticated: boolean;
    fingerprint: string;
    signals: DeviceSignals;
}
interface DeviceSignals {
    userAgent: string;
    language: string;
    languages: string[];
    platform: string;
    screenWidth: number;
    screenHeight: number;
    colorDepth: number;
    pixelRatio: number;
    timezone: string;
    timezoneOffset: number;
    touchSupport: boolean;
    cookiesEnabled: boolean;
    doNotTrack: boolean;
}

interface AdContextValueExtended extends AdContextValue {
    identity: UserIdentity | null;
    apiBase: string;
}
declare function useAds(): AdContextValueExtended;
interface AdProviderProps {
    siteId: string;
    apiBase?: string;
    authenticatedAccountId?: string;
    children: ReactNode;
}
declare function AdProvider({ siteId, apiBase, authenticatedAccountId, children, }: AdProviderProps): React__default.ReactElement;
interface AdProps {
    slot: AdSlot;
    position?: AdPosition;
    className?: string;
    style?: React__default.CSSProperties;
    fallback?: ReactNode;
    onImpression?: (adId: string) => void;
    onClick?: (adId: string) => void;
}
declare function Ad({ slot, position, className, style, fallback, onImpression, onClick, }: AdProps): React__default.ReactElement | null;

type CheckoutOrderType = OrderType;
interface CimplifyCheckoutProps {
    client: CimplifyClient;
    businessId?: string;
    cartId?: string;
    /** Confirm this hosted/durable intent instead of minting a new cart intent. */
    intentId?: string;
    /** Bind hosted calls to the checkout-session owner rather than the API session. */
    hostedSessionId?: string;
    /** Initial render hint; server authority is re-read before confirmation. */
    initialTerms?: CheckoutTermsView;
    locationId?: string;
    linkUrl?: string;
    orderTypes?: CheckoutOrderType[];
    defaultOrderType?: CheckoutOrderType;
    submitLabel?: string;
    enrollInLink?: boolean;
    onComplete: (result: ProcessCheckoutResult) => void;
    onError?: (error: {
        code: string;
        message: string;
    }) => void;
    onStatusChange?: (status: CheckoutStatus, context: CheckoutStatusContext) => void;
    appearance?: {
        theme?: "light" | "dark";
        variables?: {
            primaryColor?: string;
            fontFamily?: string;
            borderRadius?: string;
        };
    };
    className?: string;
}
declare function CimplifyCheckout({ client, businessId, cartId, intentId, hostedSessionId, initialTerms, locationId, linkUrl, orderTypes, defaultOrderType, submitLabel, enrollInLink, onComplete, onError, onStatusChange, appearance, className, }: CimplifyCheckoutProps): React__default.ReactElement;

interface NavItem {
    label: string;
    href: string;
    icon?: ReactNode;
    external?: boolean;
}
interface IdentitySummary {
    addresses?: number;
    paymentMethods?: number;
    shops?: number;
}
interface TimelineStep {
    label: string;
    time?: string;
    state: "done" | "current" | "pending";
    icon?: ReactNode;
}
interface OrderRowData {
    id: string;
    href?: string;
    summary: string;
    meta: string;
    status: OrderRowStatus;
    total: string;
    thumbnails?: string[];
}
type OrderRowStatus = {
    kind: "preparing";
    label: string;
} | {
    kind: "delivered";
    label?: string;
} | {
    kind: "completed";
    label?: string;
} | {
    kind: "cancelled";
    label?: string;
} | {
    kind: "active";
    label: string;
} | {
    kind: "paused";
    label?: string;
};
interface SubscriptionRowData {
    id: string;
    href?: string;
    title: string;
    meta: string;
    status: OrderRowStatus;
    price: string;
    unit: string;
    paused?: boolean;
    cancelled?: boolean;
}
interface FilterTabItem<T extends string = string> {
    label: string;
    count?: number;
    value: T;
}

interface ButtonProps extends React__default.ButtonHTMLAttributes<HTMLButtonElement> {
    variant?: "primary" | "secondary" | "ghost" | "danger";
    size?: "sm" | "md";
    asChild?: boolean;
}
declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
interface StatusProps {
    status: OrderRowStatus;
    className?: string;
}
declare function Status({ status, className }: StatusProps): react_jsx_runtime.JSX.Element;
interface BackLinkProps extends React__default.AnchorHTMLAttributes<HTMLAnchorElement> {
    label?: string;
}
declare function BackLink({ label, className, ...props }: BackLinkProps): react_jsx_runtime.JSX.Element;
interface FilterTabsProps<T extends string = string> {
    items: FilterTabItem<T>[];
    value: T;
    onChange?: (value: T) => void;
    className?: string;
}
declare function FilterTabs<T extends string = string>({ items, value, onChange, className, }: FilterTabsProps<T>): react_jsx_runtime.JSX.Element;
interface EmptyStateProps {
    glyph?: React__default.ReactNode;
    title: string;
    description?: string;
    action?: React__default.ReactNode;
    className?: string;
}
declare function EmptyState({ glyph, title, description, action, className }: EmptyStateProps): react_jsx_runtime.JSX.Element;
interface ErrorStateProps {
    title?: string;
    message?: string;
    onRetry?: () => void;
    className?: string;
}
declare function ErrorState({ title, message, onRetry, className, }: ErrorStateProps): react_jsx_runtime.JSX.Element;
interface SkeletonProps {
    className?: string;
    variant?: "row" | "block";
}
declare function Skeleton({ className, variant }: SkeletonProps): react_jsx_runtime.JSX.Element;
interface ToastProps {
    title: string;
    description?: string;
    onUndo?: () => void;
    onDismiss?: () => void;
    className?: string;
}
declare function Toast({ title, description, onUndo, onDismiss, className }: ToastProps): react_jsx_runtime.JSX.Element;

interface AccountShellProps {
    sidebar: React__default.ReactNode;
    children: React__default.ReactNode;
    className?: string;
}
declare function AccountShell({ sidebar, children, className }: AccountShellProps): react_jsx_runtime.JSX.Element;
interface AccountSidebarProps {
    children: React__default.ReactNode;
    scopeNote?: React__default.ReactNode;
    className?: string;
}
declare function AccountSidebar({ children, scopeNote, className }: AccountSidebarProps): react_jsx_runtime.JSX.Element;
interface AccountIdentityStripProps {
    name: string;
    email?: string;
    customerId?: string;
    className?: string;
}
declare function AccountIdentityStrip({ name, email, customerId, className, }: AccountIdentityStripProps): react_jsx_runtime.JSX.Element;
interface AccountNavProps {
    items: NavItem[];
    activeHref?: string;
    className?: string;
}
declare function AccountNav({ items, activeHref, className }: AccountNavProps): react_jsx_runtime.JSX.Element;
interface AccountHeroProps {
    eyebrow?: string;
    title: string;
    subtitle?: React__default.ReactNode;
    className?: string;
}
declare function AccountHero({ eyebrow, title, subtitle, className }: AccountHeroProps): react_jsx_runtime.JSX.Element;
interface AccountContentProps {
    children: React__default.ReactNode;
    className?: string;
}
declare function AccountContent({ children, className }: AccountContentProps): react_jsx_runtime.JSX.Element;
interface SectionProps {
    title?: string;
    meta?: React__default.ReactNode;
    action?: React__default.ReactNode;
    children: React__default.ReactNode;
    className?: string;
}
declare function Section({ title, meta, action, children, className }: SectionProps): react_jsx_runtime.JSX.Element;
interface SectionMoreProps extends React__default.AnchorHTMLAttributes<HTMLAnchorElement> {
}
declare function SectionMore({ children, className, ...props }: SectionMoreProps): react_jsx_runtime.JSX.Element;

interface HappeningPaneData {
    label: string;
    variant: "live" | "next";
    title: string;
    when: React__default.ReactNode;
    actions?: React__default.ReactNode;
}
interface HappeningCardProps {
    left?: HappeningPaneData;
    right?: HappeningPaneData;
    className?: string;
}
declare function HappeningCard({ left, right, className }: HappeningCardProps): react_jsx_runtime.JSX.Element | null;
interface ContinuityCardProps {
    glyph?: React__default.ReactNode;
    title: React__default.ReactNode;
    description?: React__default.ReactNode;
    badge?: string;
    className?: string;
}
declare function ContinuityCard({ glyph, title, description, badge, className }: ContinuityCardProps): react_jsx_runtime.JSX.Element;
interface WelcomeCardProps {
    title: string;
    description: string;
    action: React__default.ReactNode;
    className?: string;
}
declare function WelcomeCard({ title, description, action, className }: WelcomeCardProps): react_jsx_runtime.JSX.Element;
interface IdentityOfframpProps extends Omit<React__default.AnchorHTMLAttributes<HTMLAnchorElement>, "title"> {
    title?: string;
    summary?: IdentitySummary;
    className?: string;
}
declare function IdentityOfframp({ title, summary, href, className, ...props }: IdentityOfframpProps): react_jsx_runtime.JSX.Element;

interface OrderRowProps {
    order: OrderRowData;
    onSelect?: (id: string) => void;
    className?: string;
}
declare function OrderRow({ order, onSelect, className }: OrderRowProps): react_jsx_runtime.JSX.Element;
interface OrderListProps {
    orders: OrderRowData[];
    onSelect?: (id: string) => void;
    className?: string;
}
declare function OrderList({ orders, onSelect, className }: OrderListProps): react_jsx_runtime.JSX.Element;
interface OrderDetailHeaderProps {
    title: string;
    meta?: React__default.ReactNode;
    className?: string;
}
declare function OrderDetailHeader({ title, meta, className }: OrderDetailHeaderProps): react_jsx_runtime.JSX.Element;
declare function OrderDetailMetaPipe(): react_jsx_runtime.JSX.Element;
interface OrderTimelineProps {
    steps: TimelineStep[];
    className?: string;
}
declare function OrderTimeline({ steps, className }: OrderTimelineProps): react_jsx_runtime.JSX.Element;
interface OrderItemData {
    id: string;
    name: string;
    meta?: string;
    qty: number | string;
    price: string;
    thumbnail?: string;
}
interface ItemsCardProps {
    title: string;
    rightLabel?: string;
    items: OrderItemData[];
    totals?: TotalsData;
    className?: string;
}
interface TotalsData {
    rows: {
        label: string;
        value: string;
    }[];
    grandLabel: string;
    grandValue: string;
}
declare function ItemsCard({ title, rightLabel, items, totals, className }: ItemsCardProps): react_jsx_runtime.JSX.Element;
interface OrderTotalsProps {
    data: TotalsData;
    className?: string;
}
declare function OrderTotals({ data, className }: OrderTotalsProps): react_jsx_runtime.JSX.Element;
interface ContextRow {
    label: string;
    value: React__default.ReactNode;
    manageHref?: string;
    manageLabel?: string;
}
interface ContextCardProps {
    rows: ContextRow[];
    className?: string;
}
declare function ContextCard({ rows, className }: ContextCardProps): react_jsx_runtime.JSX.Element;

interface DeliveryRider {
    name: string;
    photoUrl?: string;
    vehicle?: string;
    rating?: number;
    etaLabel?: string;
    distanceLabel?: string;
}
interface DeliveryLive {
    /**
     * The live map node from the consumer's map provider (tiles + the streamed
     * driver marker). The tracker overlays the ETA / "live" pills and the rider
     * sheet on top of it. Only pass this once the delivery provider is actually
     * streaming the rider's location — otherwise omit it and the step view shows.
     */
    map: React__default.ReactNode;
    etaLabel?: string;
}
interface DeliveryTrackerProps {
    /** Journey steps, derived from order history. */
    steps: TimelineStep[];
    statusLabel?: string;
    etaLabel?: string;
    rider?: DeliveryRider;
    /** Present only when live driver tracking is available; swaps steps for the map. */
    live?: DeliveryLive;
    onTrackLive?: () => void;
    onContactRider?: () => void;
    /** `card` (default) draws its own border; `plain` sits flush inside a page section. */
    variant?: "card" | "plain";
    className?: string;
}
declare function DeliveryTracker({ steps, statusLabel, etaLabel, rider, live, onTrackLive, onContactRider, variant, className, }: DeliveryTrackerProps): React__default.ReactElement;

type CustomerInputType = "text" | "textarea" | "number" | "select" | "radio" | "multi_select" | "checkbox" | "color" | "date" | "date_time" | "date_range" | "time" | "file" | "image" | "url" | "email" | "phone" | "address" | "location" | "signature";
type LineItemSemanticKind = "allergen" | "dietary_preference" | "sensitivity" | "consent";
interface CustomerInput {
    fieldId: string;
    fieldName: string;
    fieldType: CustomerInputType | string;
    value: unknown;
    semanticKind?: LineItemSemanticKind;
}
interface LineSelection {
    quantity?: number;
    name: string;
    variantName?: string;
    /** Pre-formatted, e.g. "+GHS 120.00". */
    priceLabel?: string;
}
interface LineScheduling {
    /** Pre-formatted window, e.g. "Sat, Apr 4 · 9:00–11:00 AM". */
    whenLabel: string;
    staffName?: string;
    confirmationCode?: string;
}
type LineStateTone = "preparing" | "ready" | "delivered" | "booked" | "cancelled" | "default";
interface DigitalFulfillment {
    statusLabel: string;
    tone?: "ready" | "accessed" | "revoked" | "pending";
    usageSummary?: string;
    onDownload?: () => void;
}
interface AccountLineItemData {
    id: string;
    name: string;
    imageUrl?: string;
    /** One quiet line under the name (variant · qty · add-ons). Auto-composed if omitted. */
    subtitle?: string;
    /** Pre-formatted, e.g. "GHS 150.00". */
    priceLabel: string;
    lineType?: "product" | "service" | "bundle" | "composite" | "digital";
    stateLabel?: string;
    stateTone?: LineStateTone;
    scheduling?: LineScheduling;
    digital?: DigitalFulfillment;
    variant?: string;
    addOns?: {
        name: string;
        priceLabel?: string;
    }[];
    /** Bundle components. */
    includes?: LineSelection[];
    /** Composite / build-your-own selections. */
    customisations?: LineSelection[];
    customerInputs?: CustomerInput[];
}
interface AccountLineItemProps {
    item: AccountLineItemData;
    className?: string;
}
declare function AccountLineItem({ item, className }: AccountLineItemProps): React__default.ReactElement;
declare function LineItemDetails({ item, className, }: {
    item: AccountLineItemData;
    className?: string;
}): React__default.ReactElement;
interface AccountLineItemsProps {
    items: AccountLineItemData[];
    className?: string;
}
declare function AccountLineItems({ items, className }: AccountLineItemsProps): React__default.ReactElement;

interface OrderViewPaymentRow {
    label: string;
    value: string;
    /** `positive` renders the value in the success colour (discounts, free delivery). */
    tone?: "default" | "positive";
}
interface OrderViewDelivery {
    label?: string;
    note?: string;
    steps: TimelineStep[];
    statusLabel?: string;
    etaLabel?: string;
    rider?: DeliveryRider;
    live?: DeliveryLive;
    onTrackLive?: () => void;
    onContactRider?: () => void;
}
interface OrderViewPayment {
    stateLabel?: string;
    stateTone?: "positive" | "warning" | "muted";
    rows: OrderViewPaymentRow[];
    total: {
        label: string;
        value: string;
    };
    /** Method line — e.g. a brand chip + masked number. */
    method?: React__default.ReactNode;
}
type OrderStatusTone = "progress" | "positive" | "muted";
interface AccountOrderViewProps {
    /** Human order number (user_friendly_id), not the UUID. */
    orderNumber: string;
    /** Sub-line, e.g. "Placed today at 10:02 AM · 5 items". */
    placedLabel?: string;
    statusLabel?: string;
    statusTone?: OrderStatusTone;
    items: AccountLineItemData[];
    itemsLabel?: string;
    delivery?: OrderViewDelivery;
    payment: OrderViewPayment;
    shipTo?: {
        heading?: string;
        name?: string;
        lines: React__default.ReactNode;
    };
    actions?: React__default.ReactNode;
    onBack?: () => void;
    backLabel?: string;
    className?: string;
}
declare function AccountOrderView({ orderNumber, placedLabel, statusLabel, statusTone, items, itemsLabel, delivery, payment, shipTo, actions, onBack, backLabel, className, }: AccountOrderViewProps): React__default.ReactElement;

/** Map one enriched order line to the `<AccountLineItem>` view-model. */
declare function toAccountLineItem(item: EnrichedOrderItem, currency: CurrencyCode): AccountLineItemData;
declare function toAccountLineItems(items: EnrichedOrderItem[], currency: CurrencyCode): AccountLineItemData[];
interface ToAccountOrderViewOptions {
    placedLabel?: string;
    onBack?: () => void;
}
/** Map the storefront `EnrichedOrder` to `<AccountOrderView>` props. */
declare function toAccountOrderView(order: EnrichedOrder, opts?: ToAccountOrderViewOptions): AccountOrderViewProps;

interface SubscriptionRowProps {
    subscription: SubscriptionRowData;
    onSelect?: (id: string) => void;
    iconTile?: React__default.ReactNode;
    className?: string;
}
declare function SubscriptionRow({ subscription, onSelect, iconTile, className, }: SubscriptionRowProps): react_jsx_runtime.JSX.Element;
interface SubscriptionListProps {
    subscriptions: SubscriptionRowData[];
    onSelect?: (id: string) => void;
    renderIcon?: (s: SubscriptionRowData) => React__default.ReactNode;
    className?: string;
}
declare function SubscriptionList({ subscriptions, onSelect, renderIcon, className, }: SubscriptionListProps): react_jsx_runtime.JSX.Element;
interface NextDeliveryCardProps {
    label: string;
    date: string;
    meta?: React__default.ReactNode;
    actions?: React__default.ReactNode;
    footnote?: React__default.ReactNode;
    rightFootnote?: React__default.ReactNode;
    paused?: boolean;
    className?: string;
}
declare function NextDeliveryCard({ label, date, meta, actions, footnote, rightFootnote, paused, className, }: NextDeliveryCardProps): react_jsx_runtime.JSX.Element;

interface AccountSignedOutPromptProps {
    eyebrow?: string;
    title?: string;
    description?: string;
    clientId: string;
    redirectUri: string;
    lastEmail?: string;
    onSuccess?: () => void;
    className?: string;
}
declare function AccountSignedOutPrompt({ eyebrow, title, description, clientId, redirectUri, lastEmail, onSuccess, className, }: AccountSignedOutPromptProps): react_jsx_runtime.JSX.Element;

interface MobileAccountShellProps {
    storeName: React__default.ReactNode;
    leading?: React__default.ReactNode;
    trailing?: React__default.ReactNode;
    tabBar?: React__default.ReactNode;
    children: React__default.ReactNode;
    className?: string;
}
declare function MobileAccountShell({ storeName, leading, trailing, tabBar, children, className, }: MobileAccountShellProps): react_jsx_runtime.JSX.Element;
interface MobileTabBarProps {
    items: NavItem[];
    activeHref?: string;
    className?: string;
}
declare function MobileTabBar({ items, activeHref, className }: MobileTabBarProps): react_jsx_runtime.JSX.Element;
declare function MobileBackButton({ href, label }: {
    href: string;
    label?: string;
}): react_jsx_runtime.JSX.Element;
declare function MobileMoreButton({ onClick }: {
    onClick?: () => void;
}): react_jsx_runtime.JSX.Element;

interface AccountPageBaseProps {
    customerName: string;
    customerEmail?: string;
    customerId?: string;
    merchantName: string;
    nav?: NavItem[];
    activeHref?: string;
    scopeNote?: React__default.ReactNode;
}
interface AccountDashboardPageProps extends AccountPageBaseProps {
    greeting?: string;
    activePane?: {
        label: string;
        title: string;
        when: React__default.ReactNode;
        actions?: React__default.ReactNode;
    };
    upcomingPane?: {
        label: string;
        title: string;
        when: React__default.ReactNode;
        actions?: React__default.ReactNode;
    };
    continuity?: {
        glyph?: React__default.ReactNode;
        title: React__default.ReactNode;
        description?: React__default.ReactNode;
        badge?: string;
    };
    recentOrders?: OrderRowData[];
    identitySummary?: IdentitySummary;
    welcomeCta?: React__default.ReactNode;
}
declare function AccountDashboardPage({ customerName, customerEmail, customerId, merchantName, nav, activeHref, scopeNote, greeting, activePane, upcomingPane, continuity, recentOrders, identitySummary, welcomeCta, }: AccountDashboardPageProps): react_jsx_runtime.JSX.Element;
interface AccountOrdersPageProps extends AccountPageBaseProps {
    title?: string;
    description?: React__default.ReactNode;
    orders: OrderRowData[];
    filterTabs?: React__default.ReactNode;
    loadMore?: React__default.ReactNode;
    emptyAction?: React__default.ReactNode;
    emptyTitle?: string;
    emptyDescription?: string;
}
declare function AccountOrdersPage({ customerName, customerEmail, customerId, merchantName, nav, activeHref, scopeNote, title, description, orders, filterTabs, loadMore, emptyAction, emptyTitle, emptyDescription, }: AccountOrdersPageProps): react_jsx_runtime.JSX.Element;
interface AccountOrderDetailPageProps extends AccountPageBaseProps {
    title: string;
    metaText: string;
    orderId: string;
    status: OrderRowStatus;
    timelineSteps: TimelineStep[];
    itemsTitle?: string;
    itemsRightLabel?: string;
    items: OrderItemData[];
    totals: TotalsData;
    contextRows?: {
        label: string;
        value: React__default.ReactNode;
        manageHref?: string;
    }[];
    primaryAction?: React__default.ReactNode;
    secondaryAction?: React__default.ReactNode;
    continuity?: {
        glyph?: React__default.ReactNode;
        title: React__default.ReactNode;
        description?: React__default.ReactNode;
    };
}
declare function AccountOrderDetailPage({ customerName, customerEmail, customerId, merchantName, nav, activeHref, scopeNote, title, metaText, orderId, status, timelineSteps, itemsTitle, itemsRightLabel, items, totals, contextRows, primaryAction, secondaryAction, continuity, }: AccountOrderDetailPageProps): react_jsx_runtime.JSX.Element;
interface AccountSubscriptionsPageProps extends AccountPageBaseProps {
    active?: SubscriptionRowData[];
    paused?: SubscriptionRowData[];
    past?: SubscriptionRowData[];
    emptyAction?: React__default.ReactNode;
    emptyTitle?: string;
    emptyDescription?: string;
}
declare function AccountSubscriptionsPage({ customerName, customerEmail, customerId, merchantName, nav, activeHref, scopeNote, active, paused, past, emptyAction, emptyTitle, emptyDescription, }: AccountSubscriptionsPageProps): react_jsx_runtime.JSX.Element;
interface AccountSubscriptionDetailPageProps extends AccountPageBaseProps {
    title: string;
    metaText: string;
    status: OrderRowStatus;
    paused?: boolean;
    nextDeliveryLabel: string;
    nextDeliveryDate: string;
    nextDeliveryMeta?: React__default.ReactNode;
    nextDeliveryActions?: React__default.ReactNode;
    nextDeliveryFootnote?: React__default.ReactNode;
    nextDeliveryRightFootnote?: React__default.ReactNode;
    itemsTitle?: string;
    items: OrderItemData[];
    totals?: TotalsData;
    contextRows?: {
        label: string;
        value: React__default.ReactNode;
        manageHref?: string;
    }[];
    toast?: React__default.ReactNode;
    cancelAction?: React__default.ReactNode;
}
declare function AccountSubscriptionDetailPage({ customerName, customerEmail, customerId, merchantName, nav, activeHref, scopeNote, title, metaText, status, paused, nextDeliveryLabel, nextDeliveryDate, nextDeliveryMeta, nextDeliveryActions, nextDeliveryFootnote, nextDeliveryRightFootnote, itemsTitle, items, totals, contextRows, toast, cancelAction, }: AccountSubscriptionDetailPageProps): react_jsx_runtime.JSX.Element;

declare const DashboardIcon: () => react_jsx_runtime.JSX.Element;
declare const OrdersIcon: () => react_jsx_runtime.JSX.Element;
declare const SubscriptionsIcon: () => react_jsx_runtime.JSX.Element;
declare const IdentityIcon: () => react_jsx_runtime.JSX.Element;
declare const SignOutIcon: () => react_jsx_runtime.JSX.Element;
declare const DashboardIcon20: () => react_jsx_runtime.JSX.Element;
declare const OrdersIcon20: () => react_jsx_runtime.JSX.Element;
declare const SubscriptionsIcon20: () => react_jsx_runtime.JSX.Element;
declare const CheckIcon: () => react_jsx_runtime.JSX.Element;
declare const OvenIcon: () => react_jsx_runtime.JSX.Element;
declare const DeliveryTruckIcon: () => react_jsx_runtime.JSX.Element;
declare const PackageIcon: () => react_jsx_runtime.JSX.Element;
declare const BoxIcon24: () => react_jsx_runtime.JSX.Element;

interface CimplifySignInButtonProps extends Omit<SignInOptions, "onSuccess" | "onError"> {
    variant?: "primary" | "outline" | "dark" | "text";
    label?: string;
    className?: string;
    disabled?: boolean;
    onSuccess?: () => void;
    onError?: (err: {
        error: string;
        description?: string;
    }) => void;
    fullWidth?: boolean;
}
declare function CimplifySignInButton({ variant, label, className, disabled, fullWidth, onSuccess, onError, ...signInOpts }: CimplifySignInButtonProps): React__default.ReactElement;

interface CimplifyClientSession {
    sub: string;
    name?: string;
    email?: string;
    emailVerified?: boolean;
    phoneNumber?: string;
    phoneNumberVerified?: boolean;
    exp: number;
    iat: number;
}
interface UseCimplifySessionOptions {
    sessionUri?: string;
}
interface UseCimplifySessionResult {
    session: CimplifyClientSession | null;
    loading: boolean;
    refresh: () => Promise<void>;
}
declare function useCimplifySession(options?: UseCimplifySessionOptions): UseCimplifySessionResult;

interface UserButtonLink {
    label: string;
    href: string;
    icon?: React__default.ReactNode;
    external?: boolean;
}
interface CimplifyUserButtonProps {
    /** Controlled session. When omitted, the component reads it from `sessionUri`. */
    session?: CimplifyClientSession | null;
    /** Session endpoint for the uncontrolled case. Defaults to `/auth/session`. */
    sessionUri?: string;
    /**
     * Storefront-scoped quick links shown in the menu. These resolve against the
     * merchant's own pages (the business-scoped token already in the page reads
     * the data). Defaults to the native `/account/*` routes.
     */
    links?: UserButtonLink[];
    /**
     * Cross-merchant identity home. Profile, security, passkeys and devices live
     * on the root session at `link.cimplify.io` — never in the merchant frame —
     * so this is always an external link.
     */
    identityUrl?: string;
    /** Sign-out target. A `<form>` POST is used so the BFF can clear cookies. */
    signOutHref?: string;
    onSignOut?: () => void;
    /** Signed-out state delegates to the hosted OAuth flow. */
    clientId?: string;
    redirectUri?: string;
    signInLabel?: string;
    onSignIn?: () => void;
    /** Hide the name beside the avatar (avatar-only trigger). */
    hideName?: boolean;
    /** Menu alignment relative to the trigger. */
    align?: "start" | "end";
    className?: string;
}
declare function CimplifyUserButton({ session: controlledSession, sessionUri, links, identityUrl, signOutHref, onSignOut, clientId, redirectUri, signInLabel, onSignIn, hideName, align, className, }: CimplifyUserButtonProps): React__default.ReactElement | null;

interface PriceProps {
    /** The amount, denominated in `currency` (or the business base currency). */
    amount: number | string;
    /**
     * Currency the `amount` is denominated in. Pass the product/order currency
     * so the value renders correctly during SSR — before the provider has
     * loaded the business client-side. Falls back to the provider's base
     * currency, then USD.
     */
    currency?: CurrencyCode;
    /** Optional CSS class name for the wrapping span. */
    className?: string;
    /** Optional prefix rendered before the formatted price (e.g. "+"). */
    prefix?: string;
    /**
     * Apply the provider's FX display-currency override when one is active.
     * Default true. The conversion is a post-hydration enhancement: it only
     * engages once an FX rate has loaded client-side, so SSR and first-paint
     * output always match and no currency flash occurs.
     */
    convert?: boolean;
}
/**
 * Price — renders a formatted price value.
 *
 * Currency is resolved from the `currency` prop (the amount's source currency),
 * falling back to the provider's base currency, then USD. Because the source
 * currency comes from data rather than the client-only provider bootstrap, an
 * explicit `currency` renders correctly during SSR.
 *
 * FX display-currency conversion (when a user picks a non-base display
 * currency) is layered on top after hydration, and only when the source is the
 * base currency the FX rate is computed from. It never affects the server or
 * first-paint render, so there is no hydration mismatch.
 */
declare function Price({ amount, currency, className, prefix, convert, }: PriceProps): React__default.ReactElement;

type PrefetchMode = "aggressive" | "hover" | "off";
interface PrefetchOptions {
    mode?: PrefetchMode;
    rootMargin?: string;
    images?: boolean;
}
interface ResolvedPrefetchOptions {
    mode: PrefetchMode;
    rootMargin: string;
    images: boolean;
}
interface CimplifyLinkProps {
    href: string;
    className?: string;
    children: ReactNode;
    onPointerEnter?: React__default.PointerEventHandler<Element>;
    onFocus?: React__default.FocusEventHandler<Element>;
}
type CimplifyLinkComponent = React__default.ComponentType<CimplifyLinkProps>;
interface CimplifyClientContextValue {
    client: CimplifyClient;
    business: Business | null;
    currency: string;
    country: string;
    locations: Location[];
    isReady: boolean;
    prefetch: ResolvedPrefetchOptions;
    linkComponent: CimplifyLinkComponent | null;
    /** The business's pricing currency (always the base, for API calls). */
    baseCurrency: string;
    /**
     * When false, collection-backed hooks (`useCart`, etc.) skip optimistic
     * updates and fall back to fire-and-refetch. Default true. Mainly useful
     * for e2e test environments where deterministic UI is preferred over
     * perceived speed.
     */
    optimistic: boolean;
}
interface CimplifyStateContextValue {
    currentLocation: Location | null;
    setCurrentLocation: (location: Location) => void;
    /** The currency prices are displayed in. Equals baseCurrency when no FX override is set. */
    displayCurrency: string;
    /** Set a display currency override for FX conversion. Pass null to reset to base currency. */
    setDisplayCurrency: (currency: string | null) => void;
    /** Convert a base-currency amount to the display currency. No-op when currencies match. */
    convertPrice: (amount: number | string) => number;
    /** Current FX rate (baseCurrency → displayCurrency). Null when no conversion is active. */
    fxRate: number | null;
}
interface CimplifyContextValue extends CimplifyClientContextValue, CimplifyStateContextValue {
}
interface CimplifyProviderProps {
    client?: CimplifyClient;
    children: ReactNode;
    onLocationChange?: (location: Location) => void;
    /**
     * Server-fetched business to seed the provider. When provided, `business`
     * and `baseCurrency` are correct on the first (server) render, so prices
     * render in the right currency during SSR with no loading flash. Pass from
     * a Server Component via `getServerClient().business.getInfo()`. Passing
     * `null` marks "no business" as resolved (still skips the loading state).
     */
    initialBusiness?: Business | null;
    /** Server-fetched locations to seed the provider alongside `initialBusiness`. */
    initialLocations?: Location[];
    /**
     * Toggle hidden optimistic UI for collection-backed hooks. Default true.
     * Set to false to disable optimistic updates app-wide (e.g. e2e tests).
     */
    optimistic?: boolean;
    prefetch?: PrefetchOptions;
    linkComponent?: CimplifyLinkComponent;
}
declare function CimplifyProvider({ client, children, onLocationChange, initialBusiness, initialLocations, optimistic, prefetch, linkComponent, }: CimplifyProviderProps): React__default.ReactElement;
declare function useCimplify(): CimplifyContextValue;
declare function useOptionalCimplify(): CimplifyContextValue | null;
declare function useCimplifyClient(): CimplifyClientContextValue;

interface CachedQueryBaseOptions {
    enabled?: boolean;
    client?: CimplifyClient;
}

interface UseProductsOptions extends CachedQueryBaseOptions {
    category?: string;
    taxonomy?: string;
    search?: string;
    featured?: boolean;
    limit?: number;
    sort_by?: "name" | "price" | "created_at" | "updated_at";
    sort_order?: "asc" | "desc";
    tags?: string[];
    in_stock?: boolean;
    min_price?: number;
    max_price?: number;
    page?: number;
    properties?: Record<string, string>;
}
interface UseProductsResult {
    products: Product[];
    is_complete: boolean;
    total_available?: number;
    pagination?: Pagination;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function prefetchProducts(client: CimplifyClient, options: UseProductsOptions): Promise<void> | undefined;
declare function useProducts(options?: UseProductsOptions): UseProductsResult;

interface UseProductOptions extends CachedQueryBaseOptions {
}
interface UseProductResult {
    product: ProductWithDetails | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function prefetchProduct(client: CimplifyClient, slugOrId: string): Promise<void> | undefined;
declare function useProduct(slugOrId: string | null | undefined, options?: UseProductOptions): UseProductResult;

interface UseCategoriesOptions extends CachedQueryBaseOptions {
}
interface UseCategoriesResult {
    categories: Category[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useCategories(options?: UseCategoriesOptions): UseCategoriesResult;

interface CartVariantSelection {
    id: string;
    name: string;
    price_adjustment?: Money;
    /** Canonical evaluated variant price in the active shopper scope. */
    price_info?: ChosenPrice;
}
interface CartAddOnOptionSelection {
    id: string;
    name: string;
    add_on_id?: string;
    default_price?: Money;
}
interface UseCartItem {
    id: string;
    product: Product;
    quantity: number;
    locationId?: string;
    variantId?: string;
    variant?: CartVariantSelection;
    quoteId?: string;
    addOnOptionIds?: string[];
    addOnOptions?: CartAddOnOptionSelection[];
    bundleSelections?: BundleSelectionInput[];
    compositeSelections?: ComponentSelectionInput[];
    specialInstructions?: string;
    scheduledStart?: string;
    scheduledEnd?: string;
    staffId?: string;
    units?: number;
    lineType?: "simple" | "service" | "bundle" | "composite" | "digital";
    confirmationCode?: string;
    serviceStatus?: string;
    bundleResolved?: BundleSelectionData;
    compositeResolved?: CompositeSelectionData;
    customerInputs?: Array<{
        field_id: string;
        field_name: string;
        field_type: string;
        value: unknown;
    }>;
}
interface AddToCartOptions {
    locationId?: string;
    variantId?: string;
    variant?: CartVariantSelection;
    quoteId?: string;
    /** Shopper-payable unit amount used until the authoritative cart returns. */
    quotedUnitPrice?: Money;
    addOnOptionIds?: string[];
    addOnOptions?: CartAddOnOptionSelection[];
    bundleSelections?: BundleSelectionInput[];
    compositeSelections?: ComponentSelectionInput[];
    specialInstructions?: string;
    scheduledStart?: string;
    scheduledEnd?: string;
    staffId?: string;
    resourceId?: string;
    units?: number;
    billingPlanId?: string;
    customerInputs?: Array<{
        field_id: string;
        value: unknown;
    }>;
}

interface UseCartOptions {
    client?: CimplifyClient;
    locationId?: string;
    currency?: string;
}
interface UseCartResult {
    items: UseCartItem[];
    itemCount: number;
    subtotal: number;
    tax: number;
    taxRate: number | null;
    taxInclusive: boolean;
    /** Present totals gross: inclusive arithmetic or a gross_required policy. */
    displayGross: boolean;
    taxJurisdictionLabel: string | null;
    total: number;
    currency: string;
    isEmpty: boolean;
    isLoading: boolean;
    /** Any pending optimistic op is in flight. */
    isOptimistic: boolean;
    /** Number of pending ops contributing to the rendered view. */
    pendingOpCount: number;
    addItem: (product: Product, quantity?: number, options?: AddToCartOptions) => Promise<void>;
    removeItem: (itemId: string) => Promise<void>;
    updateQuantity: (itemId: string, quantity: number) => Promise<void>;
    clearCart: () => Promise<void>;
    sync: () => Promise<void>;
    reorder: (orderId: string) => Promise<ReorderResult>;
}
declare function useCart(options?: UseCartOptions): UseCartResult;

declare function isTerminalOrderStatus(status: string): boolean;
interface UseOrderOptions {
    poll?: boolean;
    pollInterval?: number;
    enabled?: boolean;
    client?: CimplifyClient;
    onStatusChange?: (previousStatus: OrderStatus, newStatus: OrderStatus, order: Order) => void;
}
interface UseOrderResult {
    order: Order | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
    isTerminal: boolean;
}
declare function useOrder(orderId: string | null | undefined, options?: UseOrderOptions): UseOrderResult;

interface UseLocationsOptions {
    client?: CimplifyClient;
}
interface UseLocationsResult {
    locations: Location[];
    currentLocation: Location | null;
    setCurrentLocation: (location: Location) => void;
    isLoading: boolean;
}
declare function useLocations(options?: UseLocationsOptions): UseLocationsResult;

interface UseCollectionsOptions extends CachedQueryBaseOptions {
}
interface UseCollectionsResult {
    collections: Collection[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useCollections(options?: UseCollectionsOptions): UseCollectionsResult;

interface UseCollectionOptions extends CachedQueryBaseOptions {
}
interface UseCollectionResult {
    collection: Collection | null;
    products: Product[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useCollection(idOrSlug: string | null | undefined, options?: UseCollectionOptions): UseCollectionResult;

interface UseSearchOptions {
    client?: CimplifyClient;
    minLength?: number;
    debounceMs?: number;
    limit?: number;
    category?: string;
    taxonomy?: string;
    tags?: string[];
    featured?: boolean;
    in_stock?: boolean;
    min_price?: number;
    max_price?: number;
    sort_by?: "name" | "price" | "created_at" | "updated_at";
    sort_order?: "asc" | "desc";
}
interface UseSearchResult {
    results: Product[];
    isLoading: boolean;
    error: CimplifyError | null;
    query: string;
    setQuery: (query: string) => void;
    clear: () => void;
}
declare function useSearch(options?: UseSearchOptions): UseSearchResult;

interface UseQuoteOptions {
    client?: CimplifyClient;
    enabled?: boolean;
    autoRefresh?: boolean;
    refreshBeforeExpiryMs?: number;
}
interface UseQuoteInput {
    productId: string;
    variantId?: string;
    locationId?: string;
    quantity?: number;
    addOnOptionIds?: string[];
    bundleSelections?: QuoteBundleSelectionInput[];
    compositeSelections?: QuoteCompositeSelectionInput[];
}
interface UseQuoteResult {
    quote: PriceQuote | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refresh: () => Promise<void>;
    isExpired: boolean;
    messages: QuoteUiMessage[];
}
declare function useQuote(input: UseQuoteInput | null | undefined, options?: UseQuoteOptions): UseQuoteResult;

interface UseTaxonomiesOptions extends CachedQueryBaseOptions {
    parentId?: string;
}
interface UseTaxonomiesResult {
    taxonomies: ProductTaxonomy[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useTaxonomies(options?: UseTaxonomiesOptions): UseTaxonomiesResult;

interface UseTaxonomyOptions extends CachedQueryBaseOptions {
}
interface UseTaxonomyResult {
    taxonomy: TaxonomyWithChildren | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useTaxonomy(id: string, options?: UseTaxonomyOptions): UseTaxonomyResult;

interface UseTaxonomyPathOptions extends CachedQueryBaseOptions {
}
interface UseTaxonomyPathResult {
    path: ProductTaxonomy[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useTaxonomyPath(id: string, options?: UseTaxonomyPathOptions): UseTaxonomyPathResult;

interface UseProductSchedulesOptions extends CachedQueryBaseOptions {
}
interface UseProductSchedulesResult {
    schedules: ProductTimeProfile[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useProductSchedules(productId: string, options?: UseProductSchedulesOptions): UseProductSchedulesResult;

interface UseProductAvailabilityOptions extends CachedQueryBaseOptions {
    locationId?: string;
}
interface UseProductAvailabilityResult {
    isAvailable: boolean | null;
    schedulesToday: ProductTimeProfile[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useProductAvailability(productId: string, options?: UseProductAvailabilityOptions): UseProductAvailabilityResult;

interface UseDealsOptions extends CachedQueryBaseOptions {
    locationId?: string;
}
interface UseDealsResult {
    deals: Deal[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useDeals(options?: UseDealsOptions): UseDealsResult;

interface UseProductsOnSaleOptions extends CachedQueryBaseOptions {
}
interface UseProductsOnSaleResult {
    products: ProductDealInfo[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useProductsOnSale(options?: UseProductsOnSaleOptions): UseProductsOnSaleResult;

interface UseProductDealsOptions extends CachedQueryBaseOptions {
}
interface UseProductDealsResult {
    deals: Deal[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useProductDeals(productId: string, options?: UseProductDealsOptions): UseProductDealsResult;

interface UseValidateDiscountOptions {
    client?: CimplifyClient;
}
interface UseValidateDiscountResult {
    validate: (code: string, orderSubtotal: string, locationId?: string) => Promise<DiscountValidation | null>;
    isValidating: boolean;
    error: CimplifyError | null;
}
declare function useValidateDiscount(options?: UseValidateDiscountOptions): UseValidateDiscountResult;

interface UseBundlesOptions extends CachedQueryBaseOptions {
}
interface UseBundlesResult {
    bundles: BundleSummary[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useBundles(options?: UseBundlesOptions): UseBundlesResult;

interface UseProductPriceInput {
    product: Product | ProductWithDetails;
    quantity?: number;
    variant?: {
        price_adjustment?: number | string;
        price_info?: ChosenPrice;
    };
    addOnOptions?: Array<{
        default_price?: number | string;
    }>;
    compositePrice?: CompositePriceResult | null;
    bundleTotalPrice?: number | null;
}
interface UseProductPriceResult {
    unitPrice: number;
    totalPrice: number;
    displayTotalPrice: number;
}
declare function useProductPrice(input: UseProductPriceInput): UseProductPriceResult;

interface UseOrdersOptions extends CachedQueryBaseOptions {
    status?: OrderStatus;
    limit?: number;
}
interface UseOrdersResult {
    orders: Order[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useOrders(options?: UseOrdersOptions): UseOrdersResult;
/**
 * Drop every cached orders list so the next mount refetches. Call after
 * placing an order — the cache would otherwise serve the stale list until GC.
 */
declare function clearOrdersCache(): void;

interface UseSubscriptionsOptions {
    status?: SubscriptionStatus;
    enabled?: boolean;
}
interface UseSubscriptionsResult {
    subscriptions: Subscription[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useSubscriptions(options?: UseSubscriptionsOptions): UseSubscriptionsResult;
interface UseSubscriptionOptions {
    enabled?: boolean;
}
interface UseSubscriptionResult {
    subscription: SubscriptionWithDetails | null;
    isLoading: boolean;
    error: CimplifyError | null;
    cancel: (reason?: string) => Promise<void>;
    pause: () => Promise<void>;
    resume: () => Promise<void>;
    skipNext: () => Promise<void>;
    refetch: () => Promise<void>;
}
declare function useSubscription(id: string | null | undefined, options?: UseSubscriptionOptions): UseSubscriptionResult;

interface UseServicesOptions extends CachedQueryBaseOptions {
}
interface UseServicesResult {
    services: Service[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useServices(options?: UseServicesOptions): UseServicesResult;

interface UseAvailableSlotsOptions extends CachedQueryBaseOptions {
    participantCount?: number;
    units?: number;
}
interface UseAvailableSlotsResult {
    slots: AvailableSlot[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useAvailableSlots(serviceId: string | null, date: string | null, options?: UseAvailableSlotsOptions): UseAvailableSlotsResult;

interface UseServiceAvailabilityOptions extends CachedQueryBaseOptions {
    participantCount?: number;
    units?: number;
    locationId?: string;
}
interface UseServiceAvailabilityResult {
    days: DayAvailability[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useServiceAvailability(serviceId: string | null, startDate: string | null, endDate: string | null, options?: UseServiceAvailabilityOptions): UseServiceAvailabilityResult;

interface UseBookingsOptions extends CachedQueryBaseOptions {
    filter?: "all" | "upcoming" | "past";
}
interface UseBookingsResult {
    bookings: CustomerBooking[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
    cancelBooking: (bookingId: string, reason?: string) => Promise<CancelBookingResult>;
}
declare function useBookings(options?: UseBookingsOptions): UseBookingsResult;

interface UseAttributeDefinitionsOptions extends CachedQueryBaseOptions {
    namespace?: string;
}
interface UseAttributeDefinitionsResult {
    definitions: CustomAttributeDefinition[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useAttributeDefinitions(options?: UseAttributeDefinitionsOptions): UseAttributeDefinitionsResult;

interface UsePropertyFacetsOptions extends CachedQueryBaseOptions {
    category_id?: string;
    product_type?: string;
}
interface UsePropertyFacetsResult {
    facets: PropertyFacet[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function usePropertyFacets(options?: UsePropertyFacetsOptions): UsePropertyFacetsResult;

interface UseBillingPlansOptions {
    enabled?: boolean;
    client?: CimplifyClient;
    customerId?: string;
    quantity?: number;
    orderValue?: number;
}
interface UseBillingPlansResult {
    plans: ProductBillingPlan[];
    subscriptionPlans: ProductBillingPlan[];
    installmentPlans: ProductBillingPlan[];
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
/**
 * Fetch eligible billing plans for a product, filtered by customer/quantity/order value.
 *
 * For unfiltered plans, use `product.billing_plans` directly from `useProduct` instead —
 * they are included in the product response and require no extra API call.
 */
declare function useBillingPlans(productId: string | null | undefined, options?: UseBillingPlansOptions): UseBillingPlansResult;

interface UseVariantSelectorOptions {
    variants: VariantView[];
    axes: VariantAxisWithValues[];
}
interface UseVariantSelectorResult {
    selectedValues: Record<string, string>;
    selectedVariant: VariantView | null;
    variantImage: string | null;
    availableValues: Record<string, Set<string>>;
    selectValue: (axisId: string, valueId: string) => void;
    reset: () => void;
}
/**
 * Multi-axis variant selector. Resolves a variant from axis selections
 * and computes which values remain available as the user narrows choices.
 *
 * ```tsx
 * const { selectedValues, selectedVariant, availableValues, selectValue } =
 *   useVariantSelector({ variants: product.variants, axes: product.variant_axes });
 *
 * // Render axes
 * axes.map(axis => axis.values.map(value => (
 *   <button
 *     disabled={!availableValues[axis.id]?.has(value.id)}
 *     onClick={() => selectValue(axis.id, value.id)}
 *     style={value.color_hex ? { backgroundColor: value.color_hex } : undefined}
 *   />
 * )));
 * ```
 */
declare function useVariantSelector(options: UseVariantSelectorOptions): UseVariantSelectorResult;

interface UseActivityStateOptions extends CachedQueryBaseOptions {
}
interface UseActivityStateResult {
    state: ActivityStateResponse | null;
    messages: SessionMessage[];
    intent: string;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
    dismissMessage: (code: string) => Promise<void>;
}
declare function useActivityState(options?: UseActivityStateOptions): UseActivityStateResult;

interface UseRecommendationsOptions extends CachedQueryBaseOptions {
    locationId?: string;
    limit?: number;
}
interface UseRecommendationsResult {
    recommendations: ActivityRecommendation[];
    intent: string;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useRecommendations(options?: UseRecommendationsOptions): UseRecommendationsResult;

interface UseDeliveryFeeOptions extends CachedQueryBaseOptions {
    latitude: number;
    longitude: number;
    country?: string;
}
interface UseDeliveryFeeResult {
    fee: DeliveryFeeResponse | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useDeliveryFee(options: UseDeliveryFeeOptions): UseDeliveryFeeResult;

interface UseDeliveryOptionsOptions extends CachedQueryBaseOptions {
    latitude: number;
    longitude: number;
    country?: string;
    /** Cart goods total — drives free-over thresholds and zone minimums. */
    orderValue?: Money;
}
interface UseDeliveryOptionsResult {
    options: DeliveryOptionsResponse | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
/** The delivery menu for an address — every merchant-named rate priced for
 * the dropoff. Render as a radio list when more than one option comes back;
 * pass the chosen option's `rate_id` as `delivery_rate_id` at checkout. */
declare function useDeliveryOptions(options: UseDeliveryOptionsOptions): UseDeliveryOptionsResult;

interface UseFxRateOptions extends CachedQueryBaseOptions {
    from: CurrencyCode;
    to: CurrencyCode;
}
interface UseFxRateResult {
    rate: FxRateResponse | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useFxRate(options: UseFxRateOptions): UseFxRateResult;

type UseStoreCreditOptions = CachedQueryBaseOptions;
interface UseStoreCreditResult {
    balance: StoreCreditBalance | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
/**
 * The signed-in shopper's store-credit balance for the current storefront.
 * Errors (and yields a null balance) for guests — gate the UI on `balance`.
 */
declare function useStoreCredit(options?: UseStoreCreditOptions): UseStoreCreditResult;

interface UseBootstrapOptions extends CachedQueryBaseOptions {
}
interface UseBootstrapResult {
    bootstrap: StorefrontBootstrap | null;
    isLoading: boolean;
    error: CimplifyError | null;
    refetch: () => Promise<void>;
}
declare function useBootstrap(options?: UseBootstrapOptions): UseBootstrapResult;

interface UseChatOptions {
    client?: CimplifyClient;
    starters?: ChatWidgetStarter[];
    pollInterval?: number;
    pollIdleInterval?: number;
}
interface UseChatResult {
    messages: ChatMessage[];
    isLoading: boolean;
    isSending: boolean;
    error: CimplifyError | null;
    isActive: boolean;
    /** The customer asked for a person; cleared when an agent message arrives. */
    humanRequested: boolean;
    /**
     * True from an accepted send on an AI-answered conversation until the
     * reply arrives (30s cap) — the AI is composing, keep typing dots up.
     */
    awaitingReply: boolean;
    /** Team-wide read watermark (ISO); customer messages at or before it were seen. */
    seenAt: string | null;
    /** True while older history may exist above the loaded messages. */
    mayHaveOlder: boolean;
    /**
     * The verified customer this session's conversation is bound to (from the
     * claim), null while anonymous. Drives "chatting as X — not you?" UI.
     */
    claimedAs: string | null;
    /**
     * Sign out of the bound identity: revokes the Link session, clears the
     * access token, mints a fresh anonymous session, and resets the loaded
     * conversation so nothing lingers for the next person at this browser.
     */
    signOut: () => Promise<boolean>;
    /**
     * Resolves true when the message was accepted; false puts the failure in
     * `error`. Pass `replyTo` to quote another loaded message.
     */
    send: (content: string, opts?: {
        replyTo?: ChatMessage;
        attachments?: ChatUploadAttachment[];
    }) => Promise<boolean>;
    startConversation: (starterText?: string) => Promise<void>;
    /** React to a loaded message. Resolves true when accepted. */
    react: (message: ChatMessage, emoji: string) => Promise<boolean>;
    /** Ask for a person. Resolves true on success. */
    requestHuman: () => Promise<boolean>;
    /** Load messages older than the earliest loaded one. Resolves true if any arrived. */
    loadOlder: () => Promise<boolean>;
    /**
     * Hydrate an existing conversation without creating one: no-op when this
     * session has no conversation yet. Call when the chat surface opens so
     * returning (and claimed) visitors see their history before sending.
     */
    openIfExisting: () => Promise<void>;
}
declare function useChat(options?: UseChatOptions): UseChatResult;

declare function useElements(): CimplifyElements | null;
declare function useElementsReady(): boolean;
interface ElementsProviderProps {
    client: CimplifyClient;
    businessId?: string;
    options?: ElementsOptions;
    children: ReactNode;
}
declare function ElementsProvider({ client, businessId, options, children, }: ElementsProviderProps): React__default.ReactElement;
interface BaseElementProps {
    className?: string;
    style?: React__default.CSSProperties;
    onReady?: () => void;
    onError?: (error: {
        code: string;
        message: string;
    }) => void;
}
interface AuthElementProps extends BaseElementProps {
    prefillEmail?: string;
    onAuthenticated?: (data: AuthenticatedData) => void;
}
declare function AuthElement({ className, style, prefillEmail, onReady, onAuthenticated, onError, }: AuthElementProps): React__default.ReactElement | null;
interface AddressElementProps extends BaseElementProps {
    mode?: "shipping" | "billing";
    onChange?: (data: {
        address: AddressInfo;
        saveToLink: boolean;
    }) => void;
}
declare function AddressElement({ className, style, mode, onReady, onChange, onError, }: AddressElementProps): React__default.ReactElement | null;
interface PaymentElementProps extends BaseElementProps {
    amount?: number;
    currency?: CurrencyCode;
    onChange?: (data: {
        paymentMethod: PaymentMethodInfo;
        saveToLink: boolean;
    }) => void;
}
declare function PaymentElement({ className, style, amount, currency, onReady, onChange, onError, }: PaymentElementProps): React__default.ReactElement | null;
declare function useCheckout(): {
    submit: (data: {
        cart_id: string;
        order_type?: OrderType;
        location_id?: string;
        scheduled_time?: string;
        tip_amount?: number;
        notes?: string;
    }) => Promise<ElementsCheckoutResult>;
    process: (options: ProcessCheckoutOptions) => Promise<ProcessCheckoutResult>;
    isLoading: boolean;
};

interface QuantitySelectorClassNames {
    root?: string;
    button?: string;
    value?: string;
}
interface QuantitySelectorProps {
    value: number;
    onChange: (value: number) => void;
    min?: number;
    max?: number;
    className?: string;
    classNames?: QuantitySelectorClassNames;
}
declare function QuantitySelector({ value, onChange, min, max, className, classNames, }: QuantitySelectorProps): React__default.ReactElement;

interface VariantSelectorClassNames {
    root?: string;
    axisLabel?: string;
    axisOptions?: string;
    option?: string;
    optionSelected?: string;
    swatch?: string;
    swatchSelected?: string;
    listLabel?: string;
    list?: string;
    name?: string;
    pricing?: string;
    adjustment?: string;
}
interface VariantSelectorProps {
    variants: VariantView[];
    variantAxes?: VariantAxisWithValues[];
    basePrice?: Money;
    currency?: CurrencyCode;
    selectedVariantId?: string;
    onVariantChange: (variantId: string | undefined, variant: VariantView | undefined) => void;
    productName?: string;
    className?: string;
    classNames?: VariantSelectorClassNames;
}
declare function VariantSelector({ variants, variantAxes, basePrice, currency, selectedVariantId, onVariantChange, productName, className, classNames, }: VariantSelectorProps): React__default.ReactElement | null;

interface AddOnSelectorClassNames {
    root?: string;
    group?: string;
    header?: string;
    name?: string;
    required?: string;
    constraint?: string;
    validation?: string;
    options?: string;
    option?: string;
    optionSelected?: string;
    optionName?: string;
    optionDescription?: string;
}
interface AddOnSelectorProps {
    addOns: AddOnWithOptions[];
    selectedOptions: string[];
    onOptionsChange: (optionIds: string[]) => void;
    currency?: CurrencyCode;
    className?: string;
    classNames?: AddOnSelectorClassNames;
}
declare function AddOnSelector({ addOns, selectedOptions, onOptionsChange, currency, className, classNames, }: AddOnSelectorProps): React__default.ReactElement | null;

interface BundleSelectorClassNames {
    root?: string;
    heading?: string;
    components?: string;
    component?: string;
    componentHeader?: string;
    componentQty?: string;
    componentName?: string;
    typeBadge?: string;
    serviceBadge?: string;
    digitalBadge?: string;
    variantPicker?: string;
    variantOption?: string;
    variantOptionSelected?: string;
    variantAdjustment?: string;
    summary?: string;
    savings?: string;
}
interface BundleSelectorProps {
    components: BundleComponentView[];
    bundlePrice?: Money;
    discountValue?: Money;
    pricingType?: BundlePriceType;
    currency?: CurrencyCode;
    onSelectionsChange: (selections: BundleSelectionInput[]) => void;
    onPriceChange?: (price: number) => void;
    onReady?: (ready: boolean) => void;
    className?: string;
    classNames?: BundleSelectorClassNames;
}
declare function BundleSelector({ components, bundlePrice, discountValue, pricingType, currency, onSelectionsChange, onPriceChange, onReady, className, classNames, }: BundleSelectorProps): React__default.ReactElement | null;

interface CompositeSelectorClassNames {
    root?: string;
    group?: string;
    groupHeader?: string;
    groupName?: string;
    required?: string;
    groupDescription?: string;
    groupConstraint?: string;
    validation?: string;
    components?: string;
    component?: string;
    componentSelected?: string;
    componentInfo?: string;
    componentName?: string;
    typeBadge?: string;
    serviceBadge?: string;
    digitalBadge?: string;
    badgePopular?: string;
    badgePremium?: string;
    componentDescription?: string;
    componentCalories?: string;
    qty?: string;
    qtyButton?: string;
    qtyValue?: string;
    summary?: string;
    summaryLine?: string;
    summaryTotal?: string;
    calculating?: string;
    priceError?: string;
}
interface CompositeSelectorProps {
    compositeId: string;
    groups: CompositeGroupView[];
    currency?: CurrencyCode;
    onSelectionsChange: (selections: ComponentSelectionInput[]) => void;
    onPriceChange?: (price: CompositePriceResult | null) => void;
    onReady?: (ready: boolean) => void;
    skipPriceFetch?: boolean;
    className?: string;
    classNames?: CompositeSelectorClassNames;
}
declare function CompositeSelector({ compositeId, groups, currency, onSelectionsChange, onPriceChange, onReady, skipPriceFetch, className, classNames, }: CompositeSelectorProps): React__default.ReactElement | null;

interface ProductCustomizerClassNames {
    root?: string;
    actions?: string;
    submitButton?: string;
    submitButtonAdded?: string;
    validation?: string;
    specialInstructions?: string;
    depositInfo?: string;
    units?: string;
    allergens?: string;
    duration?: string;
}
interface ProductCustomizerProps {
    product: ProductWithDetails;
    onAddToCart?: (product: ProductWithDetails, quantity: number, options: AddToCartOptions) => void | Promise<void>;
    /** Lets the parent swap its gallery for `variant.images` on selection. */
    onVariantChange?: (variantId: string | undefined, variant: VariantView | undefined) => void;
    showSpecialInstructions?: boolean;
    /** Submit button verb; the running total is appended. Defaults to "Add to Cart". */
    submitLabel?: string;
    className?: string;
    classNames?: ProductCustomizerClassNames;
}
declare function ProductCustomizer(props: ProductCustomizerProps): React__default.ReactElement;

interface ProductImageGalleryProps {
    images: string[];
    productName: string;
    aspectRatio?: "square" | "4/3" | "16/10" | "3/4";
    className?: string;
}
/**
 * ProductImageGallery — main image + thumbnail strip.
 *
 * Uses plain `<img>` for framework-agnostic rendering (not Next.js Image).
 */
declare function ProductImageGallery({ images, productName, aspectRatio, className, }: ProductImageGalleryProps): React__default.ReactElement | null;

interface StoreVideoProps {
    src: string;
    /** Poster shown before play + as the fallback if `<video>` isn't supported. */
    poster?: string;
    /** Accessible label; also the alt of the fallback `<img>`. */
    alt?: string;
    aspectRatio?: "square" | "4/3" | "16/9" | "16/10" | "3/4";
    /** Show native browser controls. Default off for autoplay-friendly hero clips. */
    controls?: boolean;
    /** Default `true` — muted is the only way mobile browsers allow autoplay. */
    autoplay?: boolean;
    loop?: boolean;
    muted?: boolean;
    /** Lazy-load: defer the src until the player scrolls into view. Default `true`. */
    lazy?: boolean;
    className?: string;
}
/**
 * StoreVideo — `<video>` with mobile-safe defaults (muted + playsInline + loop),
 * IntersectionObserver-driven lazy load, and a poster `<img>` fallback for
 * browsers without video support. Drop-in replacement for a static hero image.
 */
declare function StoreVideo({ src, poster, alt, aspectRatio, controls, autoplay, loop, muted, lazy, className, }: StoreVideoProps): React__default.ReactElement;

interface ProductModel3DProps {
    /** glTF or GLB URL. */
    src: string;
    /** Optional USDZ URL for iOS AR Quick Look (Safari/WebKit). */
    iosSrc?: string;
    /** Poster image shown while the model loads (and as a fallback). */
    poster?: string;
    alt?: string;
    aspectRatio?: "square" | "4/3" | "16/9" | "3/4";
    /** Enable AR mode. Lights up on iOS (Quick Look) + Android (Scene Viewer). Default `true`. */
    ar?: boolean;
    autoRotate?: boolean;
    cameraControls?: boolean;
    className?: string;
}
/**
 * ProductModel3D — interactive 3D product viewer wrapping Google's
 * `<model-viewer>` web component. Script loads on demand (one tag per page,
 * cached). AR mode auto-resolves the right OS surface: USDZ Quick Look on iOS,
 * Scene Viewer on Android, WebXR where available. Poster image shows during
 * load and as a fallback if the script can't load.
 */
declare function ProductModel3D({ src, iosSrc, poster, alt, aspectRatio, ar, autoRotate, cameraControls, className, }: ProductModel3DProps): React__default.ReactElement;

type MediaItem = {
    type: "image";
    src: string;
    alt?: string;
} | {
    type: "video";
    src: string;
    poster?: string;
    alt?: string;
} | {
    type: "model";
    src: string;
    iosSrc?: string;
    poster?: string;
    alt?: string;
};
interface MediaGalleryProps {
    items: MediaItem[];
    productName: string;
    aspectRatio?: "square" | "4/3" | "16/10" | "3/4";
    className?: string;
}
/**
 * MediaGallery — like ProductImageGallery, but accepts mixed image/video/3D
 * items in one carousel. The active item renders via the matching SDK
 * component (img / StoreVideo / ProductModel3D); thumbnails show a poster
 * (or the image itself) with a small overlay icon for video/3D.
 */
declare function MediaGallery({ items, productName, aspectRatio, className, }: MediaGalleryProps): React__default.ReactElement | null;

interface CartSummaryClassNames {
    root?: string;
    item?: string;
    itemName?: string;
    itemPrice?: string;
    quantity?: string;
    removeButton?: string;
    totals?: string;
    subtotal?: string;
    tax?: string;
    deliveryFee?: string;
    serviceCharge?: string;
    discount?: string;
    total?: string;
    checkout?: string;
    empty?: string;
    serviceInfo?: string;
    digitalInfo?: string;
    bundleBreakdown?: string;
    compositeBreakdown?: string;
    customerInputs?: string;
}
interface CartSummaryProps {
    /** Optional server cart for extended pricing details (delivery fee, service charge, discounts). */
    cart?: DisplayCart;
    onCheckout?: () => void;
    onItemRemove?: (itemId: string) => void;
    onQuantityChange?: (itemId: string, quantity: number) => void;
    emptyMessage?: string;
    /** Render the totals block (subtotal/tax/total) below the items. Default true. Hosts that show their own totals (drawer, page sidebar) should pass false. */
    showTotals?: boolean;
    /** Render the "Proceed to Checkout" button. Defaults to true if `onCheckout` is provided. */
    showCheckoutButton?: boolean;
    className?: string;
    classNames?: CartSummaryClassNames;
}
/**
 * CartSummary — renders cart line items + totals.
 *
 * NOT a drawer or modal — just the cart content. Templates wrap this in
 * their own drawer/modal shell with animations.
 */
declare function CartSummary({ cart: serverCart, onCheckout, onItemRemove, onQuantityChange, emptyMessage, showTotals, showCheckoutButton, className, classNames, }: CartSummaryProps): React__default.ReactElement;

interface AvailabilityBadgeClassNames {
    root?: string;
    dot?: string;
    label?: string;
    lowStock?: string;
    stockCount?: string;
}
interface AvailabilityBadgeProps {
    /** The product to check availability for. */
    product: Product;
    /** Override availability (e.g. from location_availability). */
    isAvailable?: boolean;
    /** Override stock status (e.g. from location_availability). */
    isInStock?: boolean;
    /** Current stock quantity. When provided, enables "Only X left" display. */
    stockQuantity?: number;
    /** Threshold at which stock is considered low. Default: 5. */
    lowStockThreshold?: number;
    /** Location context for availability checks. Passed through as a data attribute. */
    locationId?: string;
    className?: string;
    classNames?: AvailabilityBadgeClassNames;
}
/**
 * AvailabilityBadge — displays in-stock / out-of-stock status for tracked products.
 *
 * Returns `null` for products that don't have inventory tracking enabled,
 * since there's no meaningful stock state to show.
 */
declare function AvailabilityBadge({ product, isAvailable, isInStock, stockQuantity, lowStockThreshold, locationId, className, classNames, }: AvailabilityBadgeProps): React__default.ReactElement | null;

interface CustomerInputFieldsClassNames {
    root?: string;
    field?: string;
    label?: string;
    required?: string;
    helpText?: string;
    input?: string;
    select?: string;
    textarea?: string;
    fileInput?: string;
    colorInput?: string;
    radioGroup?: string;
    radioOption?: string;
    checkboxLabel?: string;
    priceAdjustment?: string;
    addressInput?: string;
    phoneInput?: string;
    signatureCanvas?: string;
    multiSelectGroup?: string;
    multiSelectOption?: string;
    dateRangeInput?: string;
    locationInput?: string;
}
interface CustomerInputFieldsProps {
    fields: ProductInputField[];
    values: Record<string, unknown>;
    onChange: (values: Record<string, unknown>) => void;
    onFileUpload?: (file: File, field: ProductInputField) => Promise<string>;
    currency?: CurrencyCode;
    className?: string;
    classNames?: CustomerInputFieldsClassNames;
}
declare function CustomerInputFields({ fields, values, onChange, onFileUpload, currency, className, classNames, }: CustomerInputFieldsProps): React__default.ReactElement | null;

interface AddressAutocompleteClassNames {
    root?: string;
    input?: string;
    list?: string;
    option?: string;
    activeOption?: string;
}
interface AddressAutocompleteProps {
    /** Explicit transport for non-storefront surfaces such as Cimplify Link. */
    client?: CimplifyClient;
    /** The currently resolved address, if any. Seeds the input text. */
    value?: AddressValue | null;
    /** Initial free-text value when the address has no resolved map pin. */
    initialInputValue?: string;
    /** Fires when the customer picks a suggestion and details resolve. */
    onSelect: (address: AddressValue) => void;
    /** Mirrors the text field for flows that also accept an unmapped address. */
    onInputChange?: (value: string) => void;
    /**
     * Fires on every keystroke after a selection existed — the previous
     * coordinates no longer describe what's typed, so consumers should clear
     * any address state derived from the last selection.
     */
    onDirty?: () => void;
    placeholder?: string;
    required?: boolean;
    autoFocus?: boolean;
    id?: string;
    className?: string;
    classNames?: AddressAutocompleteClassNames;
}
/** Google keys autocomplete billing to a session token that must be spent
 * (rotated) once details are fetched. */
declare function createPlacesSessionToken(): string;
/**
 * AddressAutocomplete — a Places-backed address search that resolves to a
 * full {@link AddressValue} with coordinates. Consumers may also mirror the
 * text through `onInputChange` when coordinate-free delivery is supported.
 *
 * Headless by default: style via `classNames` or the `data-cimplify-address-*`
 * attributes.
 */
declare function AddressAutocomplete({ client: explicitClient, value, initialInputValue, onSelect, onInputChange, onDirty, placeholder, required, autoFocus, id, className, classNames, }: AddressAutocompleteProps): React__default.ReactElement;

interface SaleBadgeClassNames {
    root?: string;
    percentage?: string;
    label?: string;
    originalPrice?: string;
}
interface SaleBadgeProps {
    /** Product, optionally enriched with price_info for sale detection. */
    product: Product & Partial<ProductWithPrice>;
    /** Deal info from useProductDeals / useProductsOnSale. */
    dealInfo?: ProductDealInfo;
    /** Override badge text entirely. */
    label?: string;
    /** Show the original (pre-discount) price with strikethrough styling. */
    showOriginalPrice?: boolean;
    /** Show the percentage off. Default: true. */
    showPercentage?: boolean;
    className?: string;
    classNames?: SaleBadgeClassNames;
}
/**
 * SaleBadge — shows a sale/discount indicator for a product.
 *
 * Returns `null` when there's no deal, no sale price difference, and no label override,
 * so it's safe to render unconditionally — it simply won't show for non-sale products.
 */
declare function SaleBadge({ product, dealInfo, label, showOriginalPrice, showPercentage, className, classNames, }: SaleBadgeProps): React__default.ReactElement | null;

interface SalePriceClassNames {
    root?: string;
    price?: string;
    original?: string;
    badge?: string;
    countdown?: string;
    claim?: string;
}
interface SalePriceProps {
    /** The sale overlay. When absent, the plain `amount` renders. */
    sale?: SaleInfo | null;
    /** Regular price shown when there's no sale (and the SSR/public baseline). */
    amount: number | string;
    currency?: CurrencyCode;
    /** Show the "X% OFF" / badge_text pill. Default true. */
    showBadge?: boolean;
    /** Show a live countdown to the sale's end. Default false. */
    showCountdown?: boolean;
    /** Show "claimed of N" for a capped sale. Default false. */
    showClaim?: boolean;
    className?: string;
    classNames?: SalePriceClassNames;
}
/**
 * SalePrice — the shopper-facing sale display driven by the pricing API's
 * `sale` block: the sale price in front, the original struck through, an
 * optional "% OFF" badge, countdown, and claim counter. With no `sale` it
 * degrades to a plain {@link Price}, so it's safe to render unconditionally.
 */
declare function SalePrice({ sale, amount, currency, showBadge, showCountdown, showClaim, className, classNames, }: SalePriceProps): React__default.ReactElement;
interface SaleTeaserProps {
    /** The upcoming-sale block from the product. When absent, nothing renders. */
    upcoming?: UpcomingSale | null;
    /** Override the default "Back {date}" label, e.g. ({ when }) => `Returns ${when}`. */
    children?: (formatted: {
        when: string;
    }) => React__default.ReactNode;
    className?: string;
}
/**
 * SaleTeaser — a "back this Saturday" pill for a recurring sale that isn't live
 * right now (driven by the product's `upcoming_sale`). Renders nothing until
 * mounted, so the locale-formatted date can't cause a hydration mismatch.
 */
declare function SaleTeaser({ upcoming, children, className, }: SaleTeaserProps): React__default.ReactElement | null;

interface ProductSheetClassNames {
    root?: string;
    image?: string;
    header?: string;
    name?: string;
    price?: string;
    description?: string;
    customizer?: string;
    loading?: string;
}
interface ProductSheetProps {
    /** A slim Product (triggers lazy-fetch) or a fully-loaded ProductWithDetails. */
    product: Product | ProductWithDetails;
    /** Called when the sheet should close. */
    onClose?: () => void;
    /** Override the default add-to-cart behavior. */
    onAddToCart?: (product: ProductWithDetails, quantity: number, options: AddToCartOptions) => void | Promise<void>;
    /** Custom image renderer (e.g. Next.js Image). */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    className?: string;
    classNames?: ProductSheetClassNames;
}
/**
 * ProductSheet — full product detail view composing gallery, header, and customizer.
 *
 * When given a slim `Product`, it lazy-fetches the full details via `useProduct`.
 * When given a `ProductWithDetails`, it skips the fetch entirely.
 */
declare function ProductSheet({ product, onClose, onAddToCart, renderImage, className, classNames, }: ProductSheetProps): React__default.ReactElement;

interface CardLayoutProps {
    product: Product;
    onQuickAdd?: (product: Product) => void;
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
        priority?: boolean;
    }) => React__default.ReactNode;
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React__default.ReactNode;
    }) => React__default.ReactElement;
    className?: string;
}
declare function CardImage({ src, alt, aspectRatio, renderImage, className, children, }: {
    src: string;
    alt: string;
    aspectRatio?: "square" | "3/4" | "4/3" | "16/9";
    renderImage?: CardLayoutProps["renderImage"];
    className?: string;
    children?: React__default.ReactNode;
}): React__default.ReactElement;
declare function QuickAddButton({ onClick, className, }: {
    onClick?: () => void;
    className?: string;
}): React__default.ReactElement;
declare function WishlistButton({ filled, onClick, className, }: {
    filled?: boolean;
    onClick?: () => void;
    className?: string;
}): React__default.ReactElement;
declare function SoldOutOverlay(): React__default.ReactElement;
declare function CardShell({ product, renderLink, disabled, className, children, }: {
    product: Product;
    renderLink?: CardLayoutProps["renderLink"];
    disabled?: boolean;
    className?: string;
    children: React__default.ReactNode;
}): React__default.ReactElement;

interface ServiceCardLayoutProps extends CardLayoutProps {
    slots?: AvailableSlot[];
    onBook?: (product: Product) => void;
}
declare function StandardServiceCard({ product, onBook, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare function FoodProductCard({ product, onQuickAdd, renderImage, renderLink, className, }: CardLayoutProps): React__default.ReactElement;

declare function RetailProductCard({ product, renderImage, renderLink, className, }: CardLayoutProps): React__default.ReactElement;

declare function WholesaleProductCard({ product, onQuickAdd, renderImage, renderLink, className, }: CardLayoutProps): React__default.ReactElement;

declare function DigitalProductCard({ product, renderImage, renderLink, className, }: CardLayoutProps): React__default.ReactElement;

declare function BundleProductCard({ product, onQuickAdd, renderImage, renderLink, className, }: CardLayoutProps): React__default.ReactElement;

declare function CompositeProductCard({ product, onQuickAdd, renderImage, renderLink, className, }: CardLayoutProps): React__default.ReactElement;

declare function CompactServiceCard({ product, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare function ScheduleServiceCard({ product, slots, onBook, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare function RentalServiceCard({ product, onBook, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare function AccommodationCard({ product, onBook, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare function LeaseServiceCard({ product, onBook, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare function SubscriptionCard({ product, onBook, renderImage, renderLink, className, }: ServiceCardLayoutProps): React__default.ReactElement;

declare enum CardVariant {
    Food = "food",
    Retail = "retail",
    Wholesale = "wholesale",
    Digital = "digital",
    Bundle = "bundle",
    Composite = "composite",
    Standard = "standard",
    Compact = "compact",
    Schedule = "schedule",
    Rental = "rental",
    Accommodation = "accommodation",
    Lease = "lease",
    Subscription = "subscription"
}

interface ProductCardClassNames {
    root?: string;
    imageContainer?: string;
    image?: string;
    body?: string;
    name?: string;
    description?: string;
    price?: string;
    badges?: string;
    badge?: string;
    modal?: string;
    modalOverlay?: string;
}
interface ProductCardProps {
    /** The product to display. */
    product: Product;
    /** Display mode: "card" opens a modal, "page" renders as a link. Auto-detected from product.display_mode. */
    displayMode?: "card" | "page";
    /** Explicit card variant. Auto-detected from product data when omitted. */
    variant?: CardVariant;
    /** Per-slug card map. Highest priority — maps a product slug to a custom card component. */
    cards?: Record<string, React__default.ComponentType<CardLayoutProps>>;
    /** Link href for page mode. Default: `/menu/${product.slug}` */
    href?: string;
    /** Custom modal content renderer. Receives the fully-loaded product and a close callback. */
    renderModal?: (product: ProductWithDetails, onClose: () => void) => React__default.ReactNode;
    /** Custom image renderer (e.g. Next.js Image). */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Custom link renderer for page mode (e.g. Next.js Link). */
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React__default.ReactNode;
        onPointerEnter?: React__default.PointerEventHandler<Element>;
        onFocus?: React__default.FocusEventHandler<Element>;
    }) => React__default.ReactElement;
    /** Called when quick-add button is clicked (if the resolved card supports it). */
    onQuickAdd?: (product: Product) => void;
    /** Replace the entire default card body. */
    children?: React__default.ReactNode;
    /** Image aspect ratio. Default: "4/3". */
    aspectRatio?: "square" | "4/3" | "16/10" | "3/4";
    prefetch?: PrefetchMode;
    className?: string;
    classNames?: ProductCardClassNames;
}
/**
 * ProductCard — a product display card with two modes:
 *
 * - **card** (default): clickable button that opens a Base UI Dialog modal
 * - **page**: a plain `<a>` link for SEO-friendly product pages
 */
declare function ProductCard({ product, displayMode, variant, cards, href, renderModal, renderImage, renderLink, onQuickAdd, children, aspectRatio, prefetch: prefetchProp, className, classNames, }: ProductCardProps): React__default.ReactElement;

/**
 * Sanitize merchant-authored HTML for safe rendering. Runs identically on the
 * Cloudflare Workers edge (SSR) and in the browser — no DOM dependency.
 */
declare function sanitizeRichTextHtml(html: string): string;
interface RichTextProps extends Omit<React__default.HTMLAttributes<HTMLDivElement>, "dangerouslySetInnerHTML" | "children"> {
    /** Merchant-authored HTML (e.g. a product description). Sanitized before render. */
    html?: string | null;
}
/**
 * RichText — renders sanitized merchant-authored HTML with theme-aware prose
 * styling. Headings, lists, tables, figures, quotes, code, collapsible
 * sections and host-locked embeds all display correctly; scripts, event
 * handlers and unlisted CSS are stripped.
 *
 * Returns `null` when there's no renderable content.
 */
declare function RichText({ html, className, ...rest }: RichTextProps): React__default.ReactElement | null;

interface ProductGridClassNames {
    root?: string;
    item?: string;
    empty?: string;
}
interface ProductGridProps {
    /** Products to display in the grid. */
    products: Product[];
    /** Responsive column counts at each breakpoint. */
    columns?: {
        sm?: number;
        md?: number;
        lg?: number;
        xl?: number;
    };
    /** Custom card renderer per product. */
    renderCard?: (product: Product) => React__default.ReactNode;
    /** Custom image renderer passed to default ProductCards. */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Text shown when `products` is empty. */
    emptyMessage?: string;
    className?: string;
    classNames?: ProductGridClassNames;
}
/**
 * ProductGrid — responsive CSS grid that renders ProductCards.
 *
 * Injects an inline `<style>` tag with media queries for responsive columns.
 * Uses `React.useId()` for a hydration-safe, collision-free CSS selector.
 */
declare function ProductGrid({ products, columns, renderCard, renderImage, emptyMessage, className, classNames, }: ProductGridProps): React__default.ReactElement;

declare function cn(...inputs: ClassValue[]): string;

/**
 * Project HTML to a single-line plain-text preview. NOT a security boundary —
 * output is only ever rendered as text (never as HTML). For card/meta previews
 * where tags must not appear.
 */
declare function stripHtmlToText(html: string | null | undefined): string;

/**
 * Whether an attachment should render inline as an image. The mime type is the
 * source of truth when present, but attachments scraped from tool results (and
 * some inbound channels) arrive unlabelled — falling back to the URL's
 * extension keeps those rendering as pictures instead of generic file chips.
 */
/** Only http(s) URLs may render into `href`/`src`; anything else is dropped. */
declare function safeAttachmentUrl(url: string): string | null;
declare function isImageAttachment(attachment: ChatAttachment): boolean;

interface BoundaryLabels {
    /** e.g. "Check-in" / "Pickup". */
    start: string;
    /** e.g. "Check-out" / "Return". */
    end: string;
}
/** The boundary kind a service falls back to when none is set explicitly. */
declare function defaultBoundaryKind(unit?: DurationUnit | null): Exclude<BoundaryKind, "custom">;
type BoundarySource = Pick<Product, "boundary_kind" | "boundary_start_label" | "boundary_end_label" | "duration_unit">;
/** Effective boundary kind: explicit if set, otherwise inferred from the unit. */
declare function resolveBoundaryKind(product: BoundarySource): BoundaryKind;
/**
 * The handover words a customer sees for a multi-day booking's start and end.
 * Custom kinds use the operator-authored labels; presets use built-in words.
 */
declare function getBoundaryLabels(product: BoundarySource): BoundaryLabels;

interface SearchInputClassNames {
    root?: string;
    input?: string;
    clearButton?: string;
    results?: string;
    resultItem?: string;
    empty?: string;
    loading?: string;
    resultImage?: string;
    resultName?: string;
    resultPrice?: string;
    categoryFilter?: string;
}
interface SearchInputProps {
    /** Placeholder text for the input. */
    placeholder?: string;
    /** Search options forwarded to useSearch. */
    searchOptions?: UseSearchOptions;
    /** Called when a product result is clicked. */
    onResultClick?: (product: Product) => void;
    /** Custom result item renderer. */
    renderResult?: (product: Product) => React__default.ReactNode;
    /** Show inline results dropdown. Default: true. */
    showResults?: boolean;
    /** Optional category ID to scope search results. */
    categoryId?: string;
    /** Display name for the active category filter. */
    categoryName?: string;
    className?: string;
    classNames?: SearchInputClassNames;
}
/**
 * SearchInput — search bar with debounced results dropdown.
 *
 * Wraps `useSearch` with a controlled input and optional inline results list.
 * Uses Base UI Field.Root + Input for accessible form semantics.
 */
declare function SearchInput({ placeholder, searchOptions, onResultClick, renderResult, showResults, categoryId, categoryName, className, classNames, }: SearchInputProps): React__default.ReactElement;

interface CategoryFilterClassNames {
    root?: string;
    item?: string;
    allButton?: string;
    count?: string;
}
interface CategoryFilterProps {
    /** Currently selected category ID. Null means "all". */
    selectedId?: string | null;
    /** Called when a category is selected. Null means "all". */
    onSelect: (categoryId: string | null) => void;
    /** Label for the "all" option. Default: "All". */
    allLabel?: string;
    /** Show product counts per category. Default: true. */
    showCounts?: boolean;
    className?: string;
    classNames?: CategoryFilterClassNames;
}
/**
 * CategoryFilter — horizontal or vertical list of category chips.
 *
 * Fetches categories via `useCategories` and renders selectable buttons.
 * The parent controls selection state via `selectedId` + `onSelect`.
 *
 * Built on Base UI Tabs for accessible keyboard navigation and ARIA roles.
 */
declare function CategoryFilter({ selectedId, onSelect, allLabel, showCounts, className, classNames, }: CategoryFilterProps): React__default.ReactElement;

interface DiscountInputClassNames {
    root?: string;
    input?: string;
    button?: string;
    result?: string;
    error?: string;
    success?: string;
}
interface DiscountInputProps {
    /** Current order subtotal for validation. */
    orderSubtotal: string;
    /** Location ID for location-specific discounts. */
    locationId?: string;
    /** Called when a valid discount is applied. */
    onApply?: (validation: DiscountValidation) => void;
    /** Called when discount is cleared. */
    onClear?: () => void;
    /** Placeholder text. */
    placeholder?: string;
    className?: string;
    classNames?: DiscountInputClassNames;
}
/**
 * DiscountInput — discount code input with inline validation.
 *
 * Wraps `useValidateDiscount` with a Base UI Field + Input and apply button.
 * Shows validation result inline (success with amount, or error via Field.Error).
 */
declare function DiscountInput({ orderSubtotal, locationId, onApply, onClear, placeholder, className, classNames, }: DiscountInputProps): React__default.ReactElement;

interface CategoryGridClassNames {
    root?: string;
    item?: string;
    name?: string;
    description?: string;
    count?: string;
    empty?: string;
}
interface CategoryGridProps {
    /** Override categories (skips useCategories fetch). */
    categories?: Category[];
    /** Called when a category card is clicked. */
    onSelect?: (category: Category) => void;
    /** Custom card renderer. */
    renderCard?: (category: Category) => React__default.ReactNode;
    /** Responsive column counts. */
    columns?: {
        sm?: number;
        md?: number;
        lg?: number;
    };
    /** Text shown when empty. */
    emptyMessage?: string;
    className?: string;
    classNames?: CategoryGridClassNames;
}
/**
 * CategoryGrid — responsive grid of category cards.
 *
 * Fetches categories via `useCategories` unless overridden.
 * Uses `React.useId()` for hydration-safe responsive CSS.
 */
declare function CategoryGrid({ categories: categoriesProp, onSelect, renderCard, columns, emptyMessage, className, classNames, }: CategoryGridProps): React__default.ReactElement;

interface DealBannerClassNames {
    root?: string;
    item?: string;
    description?: string;
    value?: string;
    badge?: string;
    empty?: string;
}
interface DealBannerProps {
    /** Override deals (skips useDeals fetch). For SSR, pass pre-fetched deals. */
    deals?: Deal[];
    /** Location ID for location-specific deals. */
    locationId?: string;
    /** Called when a deal is clicked. */
    onDealClick?: (deal: Deal) => void;
    /** Custom deal card renderer. */
    renderDeal?: (deal: Deal) => React__default.ReactNode;
    /** Maximum deals to show. Default: all. */
    limit?: number;
    className?: string;
    classNames?: DealBannerClassNames;
}
/**
 * DealBanner — displays active deals/promotions.
 *
 * Renders as a horizontal scrollable strip or grid of deal cards.
 */
declare function DealBanner({ deals: dealsProp, locationId, onDealClick, renderDeal, limit, className, classNames, }: DealBannerProps): React__default.ReactElement | null;

interface OrderSummaryClassNames {
    root?: string;
    header?: string;
    orderId?: string;
    status?: string;
    paymentState?: string;
    fulfillmentDetails?: string;
    deliveryAddress?: string;
    items?: string;
    lineItem?: string;
    notes?: string;
    totals?: string;
    customer?: string;
    loading?: string;
    serviceInfo?: string;
    digitalInfo?: string;
    bundleBreakdown?: string;
    compositeBreakdown?: string;
    trackingLink?: string;
    reorderButton?: string;
}
interface OrderSummaryProps {
    /** Pass an Order object directly (skips fetch). */
    order?: Order;
    /** Or pass an order ID to fetch via useOrder. */
    orderId?: string;
    /** Poll for status updates. */
    poll?: boolean;
    /** Custom line item renderer. */
    renderLineItem?: (item: LineItem) => React__default.ReactNode;
    /** Called when the reorder button is clicked. */
    onReorder?: (order: Order) => void;
    /** Called when the order status changes during polling. */
    onStatusChange?: (previousStatus: OrderStatus, newStatus: OrderStatus, order: Order) => void;
    className?: string;
    classNames?: OrderSummaryClassNames;
}
/**
 * OrderSummary — displays a single order's details, line items, and totals.
 *
 * Accepts either a pre-loaded `order` object or an `orderId` to fetch.
 * Supports polling for live status updates.
 */
declare function OrderSummary({ order: orderProp, orderId, poll, renderLineItem, onReorder, onStatusChange, className, classNames, }: OrderSummaryProps): React__default.ReactElement;

interface OrderHistoryClassNames {
    root?: string;
    item?: string;
    orderId?: string;
    status?: string;
    date?: string;
    total?: string;
    empty?: string;
    loading?: string;
    reorderButton?: string;
}
interface OrderHistoryProps {
    /** Override orders (skips fetch). For SSR, pass pre-fetched orders. */
    orders?: Order[];
    /** Filter by status. */
    status?: OrderStatus;
    /** Max orders to display. */
    limit?: number;
    /** Called when an order row is clicked. */
    onOrderClick?: (order: Order) => void;
    /** Custom order row renderer. */
    renderOrder?: (order: Order) => React__default.ReactNode;
    /** Called when the reorder button is clicked. If provided, a reorder button is rendered. */
    onReorder?: (order: Order) => void;
    /** Text shown when empty. */
    emptyMessage?: string;
    className?: string;
    classNames?: OrderHistoryClassNames;
}
/**
 * OrderHistory — list of past orders with status and totals.
 *
 * Fetches via `useOrders` unless pre-loaded orders are passed.
 */
declare function OrderHistory({ orders: ordersProp, status, limit, onOrderClick, renderOrder, onReorder, emptyMessage, className, classNames, }: OrderHistoryProps): React__default.ReactElement;

interface StoreNavClassNames {
    root?: string;
    brand?: string;
    categories?: string;
    categoryLink?: string;
    actions?: string;
    cartButton?: string;
    cartCount?: string;
    searchButton?: string;
}
interface StoreNavProps {
    /** Store/brand name. */
    storeName?: string;
    /** Custom brand element (logo, etc.). Overrides storeName. */
    renderBrand?: () => React__default.ReactNode;
    /** Override categories (skips fetch). */
    categories?: Category[];
    /** Called when a category link is clicked. */
    onCategoryClick?: (category: Category) => void;
    /** Called when the cart button is clicked. */
    onCartClick?: () => void;
    /** Called when the search button is clicked. */
    onSearchClick?: () => void;
    /** Hide category navigation. */
    hideCategories?: boolean;
    /** Hide the cart button. */
    hideCart?: boolean;
    /** Hide the search button. */
    hideSearch?: boolean;
    className?: string;
    classNames?: StoreNavClassNames;
}
/**
 * StoreNav — top navigation bar with brand, category links, cart badge, and search.
 *
 * Fetches categories via `useCategories` and cart count via `useCart`.
 * Renders as a semantic `<nav>` element.
 */
declare function StoreNav({ storeName, renderBrand, categories: categoriesProp, onCategoryClick, onCartClick, onSearchClick, hideCategories, hideCart, hideSearch, className, classNames, }: StoreNavProps): React__default.ReactElement;

interface SlotPickerClassNames {
    root?: string;
    group?: string;
    groupLabel?: string;
    slot?: string;
    slotTime?: string;
    slotPrice?: string;
    slotScarcity?: string;
    loading?: string;
    empty?: string;
}
interface SlotPickerProps {
    /** Pre-fetched slots (skips fetch). */
    slots?: AvailableSlot[];
    /** Service ID — used to fetch slots when `slots` prop is not provided. */
    serviceId?: string;
    /** Date string (YYYY-MM-DD) — used to fetch slots when `slots` prop is not provided. */
    date?: string;
    /** Number of participants for capacity-based availability. */
    participantCount?: number;
    /** Currently selected slot. */
    selectedSlot?: AvailableSlot | null;
    /** Called when a slot is selected. */
    onSlotSelect?: (slot: AvailableSlot) => void;
    /** Whether to group slots by time of day. Default: true. Ignored when `schedulingMode` is `"multi_day"`. */
    groupByTimeOfDay?: boolean;
    /** Show price on each slot. Default: true. */
    showPrice?: boolean;
    /**
     * Show a "N left" urgency tag when a slot's remaining capacity is at or below
     * this number (and above zero). Slots at zero capacity render as sold out.
     * Default: 3. Set to 0 to disable scarcity tags.
     */
    lowCapacityThreshold?: number;
    /** Currency the slot prices are denominated in. */
    currency?: CurrencyCode;
    /**
     * Hide slots whose `start_time` is already in the past. Default: true.
     * Set to false to show elapsed slots greyed-out (still un-selectable).
     */
    hideElapsedSlots?: boolean;
    /**
     * Minimum lead time (in minutes) before a slot can be booked. Slots whose
     * start is sooner than `now + minLeadMinutes` are filtered out (when
     * `hideElapsedSlots` is true) or marked unavailable. Default: 0.
     */
    minLeadMinutes?: number;
    /**
     * Service scheduling mode. When `"multi_day"`, each slot renders as a
     * stay summary (`"3 nights: Fri Apr 5, 3:00 PM → Mon Apr 8, 11:00 AM"`)
     * instead of the time-of-day label. Defaults to `"intraday"`.
     */
    schedulingMode?: SchedulingMode;
    /** Service duration unit — used for the stay summary in multi-day mode. */
    durationUnit?: DurationUnit;
    /** Service duration value — used for the stay summary in multi-day mode. */
    durationValue?: number;
    /** Text shown when no slots available. */
    emptyMessage?: string;
    /**
     * Phone number offered when a day has no bookable times. A service can be
     * unbookable for reasons the storefront cannot see, and a bare empty grid
     * reads as a broken site rather than a shop to call.
     */
    contactPhone?: string;
    className?: string;
    classNames?: SlotPickerClassNames;
}
declare function SlotPicker({ slots: slotsProp, serviceId, date, participantCount, selectedSlot, onSlotSelect, groupByTimeOfDay, showPrice, lowCapacityThreshold, currency, schedulingMode, durationUnit, durationValue, hideElapsedSlots, minLeadMinutes, emptyMessage, contactPhone, className, classNames, }: SlotPickerProps): React__default.ReactElement;

interface DateSlotPickerClassNames {
    root?: string;
    dateStrip?: string;
    dateButton?: string;
    nav?: string;
    navButton?: string;
    slots?: string;
    loading?: string;
}
interface DateSlotPickerProps {
    /** Service ID to fetch availability and slots for. */
    serviceId: string;
    /** Number of days to show in the date strip. Default: 7. */
    daysToShow?: number;
    /** Number of participants. */
    participantCount?: number;
    /** Whole units needed — forwarded to availability so short days drop out. */
    units?: number;
    /** Currently selected slot. */
    selectedSlot?: AvailableSlot | null;
    /** Called when a slot is selected. */
    onSlotSelect?: (slot: AvailableSlot, date: string) => void;
    /** Pre-fetched availability data (skips fetch). */
    availability?: DayAvailability[];
    /** Show price on slots. Default: true. */
    showPrice?: boolean;
    /** Currency the slot prices are denominated in. */
    currency?: CurrencyCode;
    /** Forwarded to `<SlotPicker>` to render multi-day stay labels. */
    schedulingMode?: SchedulingMode;
    /** Forwarded to `<SlotPicker>` — unit for the stay summary in multi-day mode. */
    durationUnit?: DurationUnit;
    /** Forwarded to `<SlotPicker>` — value for the stay summary in multi-day mode. */
    durationValue?: number;
    /** Forwarded to `<SlotPicker>` — hide slots already in the past. Default: true. */
    hideElapsedSlots?: boolean;
    /** Forwarded to `<SlotPicker>` — minimum lead time in minutes. Default: 0. */
    minLeadMinutes?: number;
    /** Forwarded to `<SlotPicker>` — offered when a day has no bookable times. */
    contactPhone?: string;
    className?: string;
    classNames?: DateSlotPickerClassNames;
}
declare function DateSlotPicker({ serviceId, daysToShow, participantCount, units, selectedSlot, onSlotSelect, availability: availabilityProp, showPrice, currency, schedulingMode, durationUnit, durationValue, hideElapsedSlots, minLeadMinutes, contactPhone, className, classNames, }: DateSlotPickerProps): React__default.ReactElement;

interface DatePickerClassNames {
    /** Outer wrapper around the trigger. */
    root?: string;
    /** The trigger button shown when the popover is closed. */
    trigger?: string;
    /** The popover panel rendered above/below the trigger. */
    popup?: string;
    /** The DayPicker root element. */
    calendar?: string;
    /** Selected day cell. */
    daySelected?: string;
    /** Today cell. */
    dayToday?: string;
    /** Disabled day cell. */
    dayDisabled?: string;
}
interface DatePickerProps {
    /** Controlled value as an ISO date string (`YYYY-MM-DD`). */
    value?: string;
    /** Called when the user picks a date. Empty string means "cleared". */
    onChange?: (value: string) => void;
    /** Placeholder text shown when no date is selected. */
    placeholder?: string;
    /** Earliest selectable date (inclusive). */
    minDate?: Date;
    /** Latest selectable date (inclusive). */
    maxDate?: Date;
    /** Arbitrary matchers passed through to DayPicker. */
    disabled?: Matcher | Matcher[];
    /** When true, the trigger button is disabled. */
    triggerDisabled?: boolean;
    /** Native form name. */
    name?: string;
    /** Required attribute on the underlying hidden input. */
    required?: boolean;
    className?: string;
    classNames?: DatePickerClassNames;
    /** Accessible label for the trigger button. */
    "aria-label"?: string;
}
/**
 * Branded date picker for storefront flows. Trigger looks like an input,
 * click opens a calendar popover. Themable via `classNames`; pairs with
 * `<TimePicker>` for datetime use cases.
 *
 * Use this in place of `<input type="date">` so the calendar UI looks the
 * same across Chrome, Safari, and Firefox.
 */
declare function DatePicker({ value, onChange, placeholder, minDate, maxDate, disabled, triggerDisabled, name, required, className, classNames, "aria-label": ariaLabel, }: DatePickerProps): React.ReactElement;

interface TimePickerClassNames {
    root?: string;
    trigger?: string;
    popup?: string;
    option?: string;
    optionSelected?: string;
}
interface TimePickerProps {
    /** Controlled value as a 24-hour `HH:mm` string. */
    value?: string;
    /** Called when the user picks a time. Empty string means "cleared". */
    onChange?: (value: string) => void;
    /** Placeholder shown when no time is selected. */
    placeholder?: string;
    /** Earliest selectable time, inclusive. `HH:mm`. Default `"00:00"`. */
    minTime?: string;
    /** Latest selectable time, inclusive. `HH:mm`. Default `"23:59"`. */
    maxTime?: string;
    /** Minutes between options. Default 30. */
    stepMinutes?: number;
    /** Display format: 12-hour with AM/PM, or 24-hour. Default `"12h"`. */
    displayFormat?: "12h" | "24h";
    /** Disable the trigger entirely. */
    triggerDisabled?: boolean;
    /** Native form name (renders a hidden input with the `HH:mm` value). */
    name?: string;
    /** Required attribute on the hidden input. */
    required?: boolean;
    className?: string;
    classNames?: TimePickerClassNames;
    "aria-label"?: string;
}
/**
 * Branded time picker for storefront flows. Trigger shows the formatted
 * time, click opens a scrollable list of options in 12- or 24-hour format.
 * Themable via `classNames`; pairs with `<DatePicker>` for datetime inputs.
 */
declare function TimePicker({ value, onChange, placeholder, minTime, maxTime, stepMinutes, displayFormat, triggerDisabled, name, required, className, classNames, "aria-label": ariaLabel, }: TimePickerProps): React.ReactElement;

interface StaffPickerClassNames {
    root?: string;
    option?: string;
    avatar?: string;
    name?: string;
    bio?: string;
}
interface StaffPickerProps {
    /** List of available staff members. */
    staff: Staff[];
    /** Currently selected staff ID, or null for "Any available". */
    selectedStaffId?: string | null;
    /** Called when a staff member is selected. Passes null for "Any available". */
    onStaffSelect?: (staffId: string | null) => void;
    /** Show "Any available" option. Default: true. */
    showAnyOption?: boolean;
    /** Label for the "Any available" option. */
    anyLabel?: string;
    className?: string;
    classNames?: StaffPickerClassNames;
}
declare function StaffPicker({ staff, selectedStaffId, onStaffSelect, showAnyOption, anyLabel, className, classNames, }: StaffPickerProps): React__default.ReactElement;

interface BookingSummaryClassNames {
    root?: string;
    header?: string;
    row?: string;
    label?: string;
    value?: string;
    totals?: string;
    deposit?: string;
    balance?: string;
}
interface BookingSummaryProps {
    /** The chosen slot — provides the date and time. */
    slot: AvailableSlot;
    /** Resolved per-booking total (variant/add-ons included), pre-deposit. */
    total: number;
    /** Selected staff member's name, when one was chosen. */
    staffName?: string | null;
    /** Service duration, shown in the header. */
    durationMinutes?: number;
    /** Deposit policy — drives the "due now" / "balance" split. */
    depositType?: DepositType;
    depositAmount?: Money;
    currency?: CurrencyCode;
    className?: string;
    classNames?: BookingSummaryClassNames;
}
/**
 * BookingSummary — a live recap of a service booking: who, when, and the
 * deposit-due / balance split derived from the product's deposit policy.
 *
 * Presentational: the host owns the selected slot, staff and quote total.
 */
declare function BookingSummary({ slot, total, staffName, durationMinutes, depositType, depositAmount, currency, className, classNames, }: BookingSummaryProps): React__default.ReactElement;

interface BookingCardClassNames {
    root?: string;
    service?: string;
    status?: string;
    time?: string;
    confirmationCode?: string;
    total?: string;
    actions?: string;
    cancelButton?: string;
    rescheduleButton?: string;
}
interface BookingCardProps {
    /** The booking to display. */
    booking: CustomerBooking;
    /** Called when cancel is clicked. */
    onCancel?: (booking: CustomerBooking) => void;
    /** Called when reschedule is clicked. */
    onReschedule?: (booking: CustomerBooking) => void;
    /** Custom renderer for the booking. */
    renderBooking?: (booking: CustomerBooking) => React__default.ReactNode;
    className?: string;
    classNames?: BookingCardClassNames;
}
declare function BookingCard({ booking, onCancel, onReschedule, renderBooking, className, classNames, }: BookingCardProps): React__default.ReactElement;

interface BookingListClassNames {
    root?: string;
    item?: string;
    loading?: string;
    empty?: string;
}
interface BookingListProps {
    /** Pre-fetched bookings (skips fetch). */
    bookings?: CustomerBooking[];
    /** Filter: "all", "upcoming", or "past". */
    filter?: "all" | "upcoming" | "past";
    /** Called when cancel is clicked on a booking. */
    onCancel?: (booking: CustomerBooking) => void;
    /** Called when reschedule is clicked on a booking. */
    onReschedule?: (booking: CustomerBooking) => void;
    /** Called when a booking is clicked. */
    onBookingClick?: (booking: CustomerBooking) => void;
    /** Custom booking renderer. */
    renderBooking?: (booking: CustomerBooking) => React__default.ReactNode;
    /** Text shown when empty. */
    emptyMessage?: string;
    className?: string;
    classNames?: BookingListClassNames;
}
declare function BookingList({ bookings: bookingsProp, filter, onCancel, onReschedule, onBookingClick, renderBooking, emptyMessage, className, classNames, }: BookingListProps): React__default.ReactElement;

interface Resource {
    id: string;
    name: string;
    description?: string;
    capacity?: number;
    floor?: string;
    image_url?: string;
    is_available?: boolean;
}
interface ResourcePickerClassNames {
    root?: string;
    option?: string;
    image?: string;
    name?: string;
    description?: string;
    meta?: string;
    capacity?: string;
    floor?: string;
    unavailable?: string;
}
interface ResourcePickerProps {
    /** List of available resources (rooms, equipment, etc.). */
    resources: Resource[];
    /** Currently selected resource ID, or null for "Any available". */
    selectedResourceId?: string | null;
    /** Called when a resource is selected. Passes null for "Any available". */
    onResourceSelect?: (resourceId: string | null) => void;
    /** Show "Any available" option. Default: true. */
    showAnyOption?: boolean;
    /** Label for the "Any available" option. */
    anyLabel?: string;
    /** Custom image renderer (e.g. Next.js Image). */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    className?: string;
    classNames?: ResourcePickerClassNames;
}
declare function roomToResource(room: Room): Resource;
declare function ResourcePicker({ resources, selectedResourceId, onResourceSelect, showAnyOption, anyLabel, renderImage, className, classNames, }: ResourcePickerProps): React__default.ReactElement;

interface BookingPageClassNames {
    root?: string;
    header?: string;
    title?: string;
    serviceInfo?: string;
    step?: string;
    stepTitle?: string;
    summary?: string;
    summaryRow?: string;
    confirmButton?: string;
    backButton?: string;
    error?: string;
    rescheduleInfo?: string;
    depositInfo?: string;
    cancellationPolicy?: string;
    resourceStep?: string;
}
interface BookingPageProps {
    /** The service being booked. */
    service: Service;
    /** The underlying product (for deposit/cancellation fields). Falls back to service fields. */
    product?: Product;
    /** Optional staff list for staff selection step. */
    staff?: Staff[];
    /** Optional resources for resource selection step (rooms, equipment, etc.). */
    resources?: Resource[];
    /** Number of participants. */
    participantCount?: number;
    /** Page title. */
    title?: string;
    /** Called after successfully adding to cart. */
    onBooked?: (slot: AvailableSlot, staffId: string | null) => void;
    /** Called when user wants to go back. */
    onBack?: () => void;
    /** Existing booking for reschedule mode. */
    existingBooking?: CustomerBooking;
    /** Called after a successful reschedule. */
    onRescheduled?: (booking: CustomerBooking, newSlot: AvailableSlot) => void;
    /** Show price on slots. Default: true. */
    showPrice?: boolean;
    className?: string;
    classNames?: BookingPageClassNames;
}
declare function BookingPage({ service, product, staff, resources, participantCount, title, onBooked, onBack, existingBooking, onRescheduled, showPrice, className, classNames, }: BookingPageProps): React__default.ReactElement;

interface BookingsPageClassNames {
    root?: string;
    header?: string;
    title?: string;
    filters?: string;
    filterButton?: string;
    list?: string;
    detail?: string;
    backButton?: string;
}
interface BookingsPageProps {
    /** Page title. */
    title?: string;
    /** Pre-fetched bookings for SSR. */
    bookings?: CustomerBooking[];
    /** Called when navigating to a booking detail (e.g. for routing). */
    onBookingNavigate?: (booking: CustomerBooking) => void;
    /** Called when cancel is clicked. */
    onCancel?: (booking: CustomerBooking) => void;
    /** Called when reschedule is clicked. */
    onReschedule?: (booking: CustomerBooking) => void;
    /** Show filter tabs. Default: true. */
    showFilters?: boolean;
    /** Custom booking renderer. */
    renderBooking?: (booking: CustomerBooking) => React__default.ReactNode;
    className?: string;
    classNames?: BookingsPageClassNames;
}
declare function BookingsPage({ title, bookings: bookingsProp, onBookingNavigate, onCancel, onReschedule, showFilters, renderBooking, className, classNames, }: BookingsPageProps): React__default.ReactElement;

interface CatalogueLayoutProps {
    products: Product[];
    categories: Category[];
    facets?: PropertyFacet[];
    isLoading: boolean;
    /** Selected category ID. */
    selectedCategory: string | null;
    onCategoryChange: (id: string | null) => void;
    /** Search query state. */
    searchQuery: string;
    onSearchChange: (query: string) => void;
    /** Sort state. */
    sortBy: string;
    sortOrder: string;
    onSortChange: (by: string, order: string) => void;
    /** In-stock filter. */
    inStockOnly: boolean;
    onInStockChange: (value: boolean) => void;
    /** Tag filters. */
    selectedTags: string[];
    availableTags?: string[];
    onTagToggle: (tag: string) => void;
    /** Price range. */
    minPrice: string;
    maxPrice: string;
    onPriceRangeChange: (min: string, max: string) => void;
    /** Pagination. */
    page: number;
    totalPages: number;
    onPageChange: (page: number) => void;
    /** Custom renderers. */
    renderCard?: (product: Product) => React.ReactNode;
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React.ReactNode;
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React.ReactNode;
    }) => React.ReactElement;
    onQuickAdd?: (product: Product) => void;
    onProductClick?: (product: Product) => void;
    title?: string;
    className?: string;
}

declare enum CatalogueTemplate {
    Default = "default",
    Compact = "compact"
}
interface CataloguePageClassNames {
    root?: string;
}
interface CataloguePageProps {
    /** Explicit template. */
    template?: CatalogueTemplate;
    /** Layout map for overrides. */
    layouts?: Partial<Record<CatalogueTemplate | string, React__default.ComponentType<CatalogueLayoutProps>>>;
    /** Page title. */
    title?: string;
    /** Pre-fetched products for SSR. */
    products?: Product[];
    /** Pre-fetched categories for SSR. */
    categories?: Category[];
    /** Pre-fetched property facets for sidebar. */
    facets?: PropertyFacet[];
    /** Available tags for filtering. */
    availableTags?: string[];
    /** Products per page. */
    pageSize?: number;
    /** Default sort. */
    defaultSort?: {
        by: string;
        order: string;
    };
    /** Custom card renderer. */
    renderCard?: (product: Product) => React__default.ReactNode;
    /** Custom image renderer. */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Custom link renderer. */
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React__default.ReactNode;
    }) => React__default.ReactElement;
    /** Quick-add handler. */
    onQuickAdd?: (product: Product) => void;
    /** Product click handler. */
    onProductClick?: (product: Product) => void;
    className?: string;
    classNames?: CataloguePageClassNames;
}
declare function CataloguePage({ template, layouts, title, products: productsProp, categories: categoriesProp, facets, availableTags, pageSize, defaultSort, renderCard, renderImage, renderLink, onQuickAdd, onProductClick, className, classNames, }: CataloguePageProps): React__default.ReactElement;

declare function DefaultCatalogueLayout({ products, categories, facets, isLoading, selectedCategory, onCategoryChange, searchQuery, onSearchChange, sortBy, sortOrder, onSortChange, inStockOnly, onInStockChange, selectedTags, availableTags, onTagToggle, minPrice, maxPrice, onPriceRangeChange, page, totalPages, onPageChange, renderCard, renderImage, renderLink, onQuickAdd, title, className, }: CatalogueLayoutProps): React__default.ReactElement;

declare function CompactCatalogueLayout({ products, categories, isLoading, selectedCategory, onCategoryChange, searchQuery, onSearchChange, renderCard, renderImage, renderLink, onQuickAdd, title, className, }: CatalogueLayoutProps): React__default.ReactElement;

interface ProductLayoutProps {
    product: ProductWithDetails;
    onAddToCart?: (product: ProductWithDetails, quantity: number, options: AddToCartOptions) => void | Promise<void>;
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    renderBreadcrumb?: (product: ProductWithDetails) => React__default.ReactNode;
    relatedProducts?: Product[];
    showRelated?: boolean;
    className?: string;
}
declare function TwoColumnGrid({ left, right, className, }: {
    left: React__default.ReactNode;
    right: React__default.ReactNode;
    className?: string;
}): React__default.ReactElement;
declare function MetadataStringList({ items, label, icon, className, }: {
    items: string[];
    label: string;
    icon?: React__default.ReactNode;
    className?: string;
}): React__default.ReactElement | null;
declare function CustomAttributesTable({ attributes, className, }: {
    attributes: CustomAttributeValue[];
    className?: string;
}): React__default.ReactElement | null;
declare function PropertiesTable({ properties, className, }: {
    properties: ProductProperty[];
    className?: string;
}): React__default.ReactElement | null;
declare function TagPills({ tags, className, }: {
    tags: string[];
    className?: string;
}): React__default.ReactElement | null;
declare function InventoryBadge({ product, className, }: {
    product: Product;
    className?: string;
}): React__default.ReactElement | null;
declare function RelatedProductsSection({ products, title, renderImage, className, }: {
    products: Product[];
    title?: string;
    renderImage?: ProductLayoutProps["renderImage"];
    className?: string;
}): React__default.ReactElement | null;

declare enum ProductTemplate {
    Default = "default",
    Food = "food",
    Wholesale = "wholesale",
    Service = "service",
    Digital = "digital",
    Bundle = "bundle",
    Composite = "composite",
    Physical = "physical"
}
interface ProductPageClassNames {
    root?: string;
    loading?: string;
}
interface ProductPageProps {
    /** Product slug or ID — used for client-side fetch when `product` is not provided. */
    productId?: string;
    /** Pre-fetched product for SSR. Skips client-side fetch when provided. */
    product?: ProductWithDetails;
    /** Per-slug page map. Highest priority — maps a product slug to a custom component. */
    pages?: Record<string, React__default.ComponentType<ProductLayoutProps>>;
    /** Per-type template map. Overrides built-in layouts for specific template keys. */
    templates?: Partial<Record<ProductTemplate | string, React__default.ComponentType<ProductLayoutProps>>>;
    /** Override add-to-cart behavior. */
    onAddToCart?: (product: ProductWithDetails, quantity: number, options: AddToCartOptions) => void | Promise<void>;
    /** Custom image renderer (e.g. Next.js Image). */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Breadcrumb renderer. Receives the product for context. */
    renderBreadcrumb?: (product: ProductWithDetails) => React__default.ReactNode;
    /** Pre-fetched related products. */
    relatedProducts?: Product[];
    /** Show related products section. Default: true. */
    showRelated?: boolean;
    className?: string;
    classNames?: ProductPageClassNames;
}
declare function ProductPage({ productId, product: productProp, pages, templates, onAddToCart, renderImage, renderBreadcrumb, relatedProducts, showRelated, className, classNames, }: ProductPageProps): React__default.ReactElement;

declare function DefaultProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

declare function FoodProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

declare function WholesaleProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

declare function ServiceProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

declare function DigitalProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

declare function BundleProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

declare function CompositeProductLayout({ product, onAddToCart, renderBreadcrumb, relatedProducts, showRelated, className, }: ProductLayoutProps): React__default.ReactElement;

interface CartLayoutProps {
    /** Cart state from useCart hook. */
    cart: UseCartResult;
    /** Called when checkout is initiated. */
    onCheckout?: () => void;
    /** Called when "continue shopping" is clicked. */
    onContinueShopping?: () => void;
    /** Called when a valid discount is applied. */
    onDiscountApply?: (validation: DiscountValidation) => void;
    /** Called when discount is removed. */
    onDiscountClear?: () => void;
    /** Show discount code input. */
    showDiscount?: boolean;
    /** Checkout button text. */
    checkoutLabel?: string;
    className?: string;
}

declare enum CartTemplate {
    Default = "default",
    Compact = "compact"
}
interface CartPageClassNames {
    root?: string;
}
interface CartPageProps {
    /** Explicit template. */
    template?: CartTemplate;
    /** Layout map for overrides. */
    layouts?: Partial<Record<CartTemplate | string, React__default.ComponentType<CartLayoutProps>>>;
    /** Page title. */
    title?: string;
    /** Called when checkout is initiated. */
    onCheckout?: () => void;
    /** Called when "continue shopping" is clicked. */
    onContinueShopping?: () => void;
    /** Called when a valid discount is applied. */
    onDiscountApply?: (validation: DiscountValidation) => void;
    /** Called when discount is removed. */
    onDiscountClear?: () => void;
    /** Show discount code input. */
    showDiscount?: boolean;
    /** Checkout button text. */
    checkoutLabel?: string;
    className?: string;
    classNames?: CartPageClassNames;
}
declare function CartPage({ template, layouts, onCheckout, onContinueShopping, onDiscountApply, onDiscountClear, showDiscount, checkoutLabel, className, classNames, }: CartPageProps): React__default.ReactElement;

declare function DefaultCartLayout({ cart, onCheckout, onContinueShopping, onDiscountApply, onDiscountClear, showDiscount, checkoutLabel, className, }: CartLayoutProps): React__default.ReactElement;

declare function CompactCartLayout({ cart, onCheckout, onContinueShopping, checkoutLabel, className, }: CartLayoutProps): React__default.ReactElement;

interface CartDrawerCtx {
    isOpen: boolean;
    open: () => void;
    close: () => void;
    toggle: () => void;
}
declare function useCartDrawer(): CartDrawerCtx;
interface ProviderProps {
    children: React__default.ReactNode;
    /** Auto-open the drawer whenever the cart's pendingOpCount goes from 0 → >0. Default: true. */
    openOnAdd?: boolean;
}
declare function CartDrawerProvider({ children, openOnAdd }: ProviderProps): React__default.ReactElement;
interface CartDrawerProps {
    /** Called when "Checkout" is clicked. Drawer auto-closes first. */
    onCheckout?: () => void;
    /** Called when "Continue Shopping" is clicked. Defaults to closing. */
    onContinueShopping?: () => void;
    /** Called when the empty state's CTA is clicked. */
    onShop?: () => void;
    /** Heading. */
    title?: string;
    /** Free-shipping threshold (in business currency, numeric). 0 disables the progress bar. */
    freeShippingThreshold?: number;
    /** Custom class on the panel. */
    className?: string;
}
declare function CartDrawer({ onCheckout, onContinueShopping, onShop, title, freeShippingThreshold, className, }: CartDrawerProps): React__default.ReactElement;

interface CheckoutPageClassNames {
    root?: string;
    header?: string;
    title?: string;
    checkout?: string;
}
interface CheckoutPageProps {
    /** Page title. */
    title?: string;
    /** Called after successful checkout. */
    onComplete: (result: ProcessCheckoutResult) => void;
    /** Called on checkout failure. */
    onError?: (error: {
        code: string;
        message: string;
    }) => void;
    /** Props forwarded to CimplifyCheckout. */
    checkoutProps?: Partial<Omit<CimplifyCheckoutProps, "client" | "onComplete" | "onError">>;
    className?: string;
    classNames?: CheckoutPageClassNames;
}
/**
 * CheckoutPage — thin page shell around CimplifyCheckout.
 *
 * Reads the CimplifyClient from CimplifyProvider context,
 * renders a page header, and delegates all checkout logic
 * to CimplifyCheckout.
 */
declare function CheckoutPage({ title, onComplete, onError, checkoutProps, className, classNames, }: CheckoutPageProps): React__default.ReactElement;

interface CollectionLayoutProps {
    collection: Collection;
    products: Product[];
    renderCard?: (product: Product) => React__default.ReactNode;
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React__default.ReactNode;
    }) => React__default.ReactElement;
    onQuickAdd?: (product: Product) => void;
    className?: string;
}

declare enum CollectionTemplate {
    Default = "default",
    Featured = "featured",
    Catalogue = "catalogue"
}
interface CollectionPageClassNames {
    root?: string;
    loading?: string;
}
interface CollectionPageProps {
    /** Collection slug or ID. */
    collectionId?: string;
    /** Pre-fetched collection for SSR. */
    collection?: Collection;
    /** Pre-fetched products for SSR. */
    products?: Product[];
    /** Per-slug page map. Highest priority — maps a collection slug to a custom layout. */
    pages?: Record<string, React__default.ComponentType<CollectionLayoutProps>>;
    /** Per-type template map. Overrides built-in layouts. */
    templates?: Partial<Record<CollectionTemplate | string, React__default.ComponentType<CollectionLayoutProps>>>;
    /** Custom card renderer. */
    renderCard?: (product: Product) => React__default.ReactNode;
    /** Custom image renderer. */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Custom link renderer. */
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React__default.ReactNode;
    }) => React__default.ReactElement;
    /** Quick add handler for cards. */
    onQuickAdd?: (product: Product) => void;
    className?: string;
    classNames?: CollectionPageClassNames;
}
declare function CollectionPage({ collectionId, collection: collectionProp, products: productsProp, pages, templates, renderCard, renderImage, renderLink, onQuickAdd, className, classNames, }: CollectionPageProps): React__default.ReactElement;

declare function DefaultCollectionLayout({ collection, products, renderCard, renderImage, renderLink, onQuickAdd, className, }: CollectionLayoutProps): React__default.ReactElement;

declare function FeaturedCollectionLayout({ collection, products, renderCard, renderImage, renderLink, onQuickAdd, className, }: CollectionLayoutProps): React__default.ReactElement;

declare function CatalogueCollectionLayout({ collection, products, renderCard, renderImage, renderLink, onQuickAdd, className, }: CollectionLayoutProps): React__default.ReactElement;

interface OrderDetailPageClassNames {
    root?: string;
    header?: string;
    title?: string;
    backButton?: string;
    summary?: string;
}
interface OrderDetailPageProps {
    /** Order ID to display. */
    orderId: string;
    /** Pre-fetched order for SSR. */
    order?: Order;
    /** Poll for status updates. Default: true. */
    poll?: boolean;
    /** Called when back button is clicked. */
    onBack?: () => void;
    /** Custom line item renderer. */
    renderLineItem?: (item: LineItem) => React__default.ReactNode;
    /** Called when the reorder button is clicked. */
    onReorder?: (order: Order) => void;
    /** Called when the order status changes during polling. */
    onStatusChange?: (previousStatus: OrderStatus, newStatus: OrderStatus, order: Order) => void;
    /** Back button label. */
    backLabel?: string;
    className?: string;
    classNames?: OrderDetailPageClassNames;
}
/**
 * OrderDetailPage — single order detail view with live status polling.
 *
 * SSR-friendly: pass `order` prop for server rendering.
 */
declare function OrderDetailPage({ orderId, order, poll, onBack, renderLineItem, onReorder, onStatusChange, backLabel, className, classNames, }: OrderDetailPageProps): React__default.ReactElement;

interface OrderHistoryPageClassNames {
    root?: string;
    header?: string;
    title?: string;
    filters?: string;
    filterButton?: string;
    list?: string;
    detail?: string;
    backButton?: string;
}
interface OrderHistoryPageProps {
    /** Page title. */
    title?: string;
    /** Pre-fetched orders for SSR. */
    orders?: Order[];
    /** Max orders to show per page. */
    limit?: number;
    /** Called when navigating to an order detail (e.g. for routing). */
    onOrderNavigate?: (order: Order) => void;
    /** Called when the reorder button is clicked. */
    onReorder?: (order: Order) => void;
    /** Show status filter tabs. Default: true. */
    showFilters?: boolean;
    /** Custom order row renderer. */
    renderOrder?: (order: Order) => React__default.ReactNode;
    className?: string;
    classNames?: OrderHistoryPageClassNames;
}
/**
 * OrderHistoryPage — order list with inline detail view and status filtering.
 *
 * SSR-friendly: pass `orders` prop for server rendering.
 * Supports both inline detail view and external navigation via `onOrderNavigate`.
 */
declare function OrderHistoryPage({ title, orders: ordersProp, limit, onOrderNavigate, onReorder, showFilters, renderOrder, className, classNames, }: OrderHistoryPageProps): React__default.ReactElement;

interface SearchLayoutProps {
    /** Search state from useSearch hook. */
    search: UseSearchResult;
    /** Property facets from getPropertyFacets. */
    facets?: PropertyFacet[];
    /** Categories for category filter. */
    categories?: Category[];
    /** Active category filter. */
    activeCategory?: string;
    /** Called when category changes. */
    onCategoryChange?: (categoryId: string | null) => void;
    /** Active tag filters. */
    activeTags?: string[];
    /** Called when tags change. */
    onTagsChange?: (tags: string[]) => void;
    /** In-stock-only toggle state. */
    inStockOnly?: boolean;
    /** Called when in-stock toggle changes. */
    onInStockChange?: (inStock: boolean) => void;
    /** Sort value. */
    sortBy?: string;
    /** Called when sort changes. */
    onSortChange?: (sort: string) => void;
    /** Custom card renderer. */
    renderCard?: (product: Product) => React.ReactNode;
    /** Custom image renderer. */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React.ReactNode;
    /** Custom link renderer. */
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React.ReactNode;
    }) => React.ReactElement;
    /** Quick-add handler. */
    onQuickAdd?: (product: Product) => void;
    /** Placeholder text for search input. */
    placeholder?: string;
    className?: string;
}

declare enum SearchTemplate {
    Default = "default",
    Compact = "compact"
}
interface SearchPageClassNames {
    root?: string;
}
interface SearchPageProps {
    /** Explicit search template. */
    template?: SearchTemplate;
    /** Layout map for overrides. AI or developer can provide custom layouts keyed by template name. */
    layouts?: Partial<Record<SearchTemplate | string, React__default.ComponentType<SearchLayoutProps>>>;
    /** Pre-fetched categories for filters. */
    categories?: Category[];
    /** Pre-fetched property facets for sidebar. */
    facets?: PropertyFacet[];
    /** Search options passed to useSearch. */
    searchOptions?: UseSearchOptions;
    /** Placeholder text for search input. */
    placeholder?: string;
    /** Custom card renderer. */
    renderCard?: (product: Product) => React__default.ReactNode;
    /** Custom image renderer. */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Custom link renderer. */
    renderLink?: (props: {
        href: string;
        className?: string;
        children: React__default.ReactNode;
    }) => React__default.ReactElement;
    /** Quick-add handler. */
    onQuickAdd?: (product: Product) => void;
    className?: string;
    classNames?: SearchPageClassNames;
}
declare function SearchPage({ template, layouts, categories, facets, searchOptions, placeholder, renderCard, renderImage, renderLink, onQuickAdd, className, classNames, }: SearchPageProps): React__default.ReactElement;

declare function DefaultSearchLayout({ search, facets, categories, activeCategory, onCategoryChange, inStockOnly, onInStockChange, sortBy, onSortChange, renderCard, renderImage, renderLink, onQuickAdd, placeholder, className, }: SearchLayoutProps): React__default.ReactElement;

declare function CompactSearchLayout({ search, categories, activeCategory, onCategoryChange, renderCard, renderImage, renderLink, onQuickAdd, placeholder, className, }: SearchLayoutProps): React__default.ReactElement;

interface DealsPageClassNames {
    root?: string;
    header?: string;
    title?: string;
    bannerSection?: string;
    productsSection?: string;
    productsTitle?: string;
    empty?: string;
    loading?: string;
}
interface DealsPageProps {
    /** Page title. */
    title?: string;
    /** Pre-fetched deals for SSR. */
    deals?: Deal[];
    /** Pre-fetched products on sale for SSR. */
    productsOnSale?: ProductDealInfo[];
    /** Pre-fetched product objects for rendering. */
    products?: Product[];
    /** Location ID for location-specific deals. */
    locationId?: string;
    /** Custom image renderer. */
    renderImage?: (props: {
        src: string;
        alt: string;
        className?: string;
    }) => React__default.ReactNode;
    /** Grid column config. */
    columns?: {
        sm?: number;
        md?: number;
        lg?: number;
        xl?: number;
    };
    className?: string;
    classNames?: DealsPageClassNames;
}
/**
 * DealsPage — promotions landing page with deal banners and on-sale products.
 *
 * SSR-friendly: pass `deals` and `productsOnSale` props for server rendering.
 */
declare function DealsPage({ title, deals: dealsProp, productsOnSale: productsOnSaleProp, products: productsProp, locationId, renderImage, columns, className, classNames, }: DealsPageProps): React__default.ReactElement;

interface LocationPickerClassNames {
    root?: string;
    item?: string;
    activeItem?: string;
    empty?: string;
    loading?: string;
}
interface LocationPickerProps {
    /** Override locations (skips useLocations fetch). For SSR, pass pre-fetched locations. */
    locations?: Location[];
    /** Override the current location. */
    currentLocation?: Location | null;
    /** Called when a location is selected. */
    onLocationChange?: (location: Location) => void;
    /** Custom location renderer. */
    renderLocation?: (location: Location, isActive: boolean) => React__default.ReactNode;
    /** Text shown when no locations are available. */
    emptyMessage?: string;
    className?: string;
    classNames?: LocationPickerClassNames;
}
/**
 * LocationPicker — renders a location selector for multi-location businesses.
 *
 * Uses `useLocations` to fetch locations unless overridden via props.
 * Returns `null` when there is only one location (no picker needed).
 */
declare function LocationPicker({ locations: locationsProp, currentLocation: currentLocationProp, onLocationChange, renderLocation, emptyMessage, className, classNames, }: LocationPickerProps): React__default.ReactElement | null;

interface RecommendationCarouselClassNames {
    root?: string;
    item?: string;
    reason?: string;
    empty?: string;
    loading?: string;
}
interface RecommendationCarouselProps {
    /** Override recommendations (skips fetch). For SSR, pass pre-fetched data. */
    recommendations?: ActivityRecommendation[];
    /** Location ID for location-specific recommendations. */
    locationId?: string;
    /** Maximum recommendations to fetch. */
    limit?: number;
    /** Called when a product recommendation is clicked. */
    onProductClick?: (recommendation: ActivityRecommendation) => void;
    /** Custom product card renderer. */
    renderProduct?: (recommendation: ActivityRecommendation) => React__default.ReactNode;
    /** Text shown when no recommendations are available. */
    emptyMessage?: string;
    className?: string;
    classNames?: RecommendationCarouselClassNames;
}
/**
 * RecommendationCarousel — displays personalized product recommendations.
 *
 * Renders a horizontal scrollable list of product cards with reason labels.
 * Returns `null` when there are no recommendations.
 */
declare function RecommendationCarousel({ recommendations: recommendationsProp, locationId, limit, onProductClick, renderProduct, emptyMessage, className, classNames, }: RecommendationCarouselProps): React__default.ReactElement | null;

interface SessionMessageBannerClassNames {
    root?: string;
    message?: string;
    text?: string;
    dismissButton?: string;
    empty?: string;
}
interface SessionMessageBannerProps {
    /** Override messages (skips fetch). For SSR, pass pre-fetched messages. */
    messages?: SessionMessage[];
    /** Called when a message is dismissed. Receives the message code. */
    onDismiss?: (code: string) => void;
    /** Custom message renderer. */
    renderMessage?: (message: SessionMessage) => React__default.ReactNode;
    className?: string;
    classNames?: SessionMessageBannerClassNames;
}
/**
 * SessionMessageBanner — renders activity-based session messages.
 *
 * Displays dismissible message cards with level-based styling (info, promotion, urgency, suggestion).
 * Returns `null` when there are no messages.
 */
declare function SessionMessageBanner({ messages: messagesProp, onDismiss, renderMessage, className, classNames, }: SessionMessageBannerProps): React__default.ReactElement | null;

interface ViewedProduct {
    product_id: string;
    product_name?: string;
    category_id?: string;
}
interface RecentlyViewedClassNames {
    root?: string;
    item?: string;
    empty?: string;
    loading?: string;
}
interface RecentlyViewedProps {
    /** Maximum number of viewed products to display. */
    limit?: number;
    /** Called when a viewed product is clicked. */
    onProductClick?: (product: ViewedProduct) => void;
    /** Custom product renderer. */
    renderProduct?: (product: ViewedProduct) => React__default.ReactNode;
    /** Text shown when no viewed products exist. */
    emptyMessage?: string;
    className?: string;
    classNames?: RecentlyViewedClassNames;
}
/**
 * RecentlyViewed — displays products the user has recently viewed during their session.
 *
 * Extracts `state.activity.viewed_products` from the activity state.
 * Returns `null` when there are no viewed products.
 */
declare function RecentlyViewed({ limit, onProductClick, renderProduct, emptyMessage, className, classNames, }: RecentlyViewedProps): React__default.ReactElement | null;

interface BillingPlanSelectorClassNames {
    root?: string;
    plan?: string;
    activePlan?: string;
    frequency?: string;
    price?: string;
    setupFee?: string;
    trialBadge?: string;
    empty?: string;
    loading?: string;
}
interface BillingPlanSelectorProps {
    /** Product ID to fetch billing plans for. */
    productId: string;
    /** Override plans (skips fetch). For SSR, pass pre-fetched plans. */
    plans?: ProductBillingPlan[];
    /** Called when a plan is selected. */
    onPlanSelect?: (plan: ProductBillingPlan | null) => void;
    /** Currently selected plan ID. */
    selectedPlanId?: string | null;
    /** Currency the plan amounts are denominated in. */
    currency?: CurrencyCode;
    /** Show a "One-time purchase" option at the top. */
    showOneTimePurchase?: boolean;
    /** Label for the one-time purchase option. Default: "One-time purchase". */
    oneTimePurchaseLabel?: string;
    /** Custom plan card renderer. */
    renderPlan?: (plan: ProductBillingPlan, isActive: boolean) => React__default.ReactNode;
    className?: string;
    classNames?: BillingPlanSelectorClassNames;
}
/**
 * BillingPlanSelector — subscription/installment plan comparison and selection.
 *
 * Renders plan cards with frequency, markup, trial, and setup fee details.
 * Returns `null` when no plans are available (and one-time purchase is hidden).
 */
declare function BillingPlanSelector({ productId, plans: plansProp, currency, onPlanSelect, selectedPlanId, showOneTimePurchase, oneTimePurchaseLabel, renderPlan, className, classNames, }: BillingPlanSelectorProps): React__default.ReactElement | null;

interface VolumePricingClassNames {
    root?: string;
    trigger?: string;
    triggerIcon?: string;
    panel?: string;
    tier?: string;
    tierActive?: string;
    tierRange?: string;
    tierPrice?: string;
}
interface VolumePricingProps {
    tiers: QuantityPricingTier[];
    currentQuantity?: number;
    defaultOpen?: boolean;
    currency?: CurrencyCode;
    className?: string;
    classNames?: VolumePricingClassNames;
}
declare function VolumePricing({ tiers, currentQuantity, defaultOpen, currency, className, classNames, }: VolumePricingProps): React__default.ReactElement | null;

interface PriceRangeProps {
    product: Product | ProductWithDetails;
    currency?: CurrencyCode;
    className?: string;
}
declare function PriceRange({ product, currency, className }: PriceRangeProps): React__default.ReactElement | null;

interface DeliveryEstimateClassNames {
    root?: string;
    fee?: string;
    currency?: string;
    notServiceable?: string;
    loading?: string;
    error?: string;
}
interface DeliveryEstimateProps {
    /** Drop-off latitude. */
    latitude: number;
    /** Drop-off longitude. */
    longitude: number;
    /** Country code for regional fee lookup. */
    country?: string;
    /** Called when the delivery fee is successfully calculated. */
    onFeeCalculated?: (fee: DeliveryFeeResponse) => void;
    className?: string;
    classNames?: DeliveryEstimateClassNames;
}
/**
 * DeliveryEstimate — displays a pre-checkout delivery fee estimate.
 *
 * Fetches the delivery fee from `client.delivery.getFee` when coordinates change.
 * Shows fee amount with currency, a "not serviceable" message, or loading state.
 */
declare function DeliveryEstimate({ latitude, longitude, country, onFeeCalculated, className, classNames, }: DeliveryEstimateProps): React__default.ReactElement | null;

interface CurrencySelectorClassNames {
    root?: string;
    option?: string;
    activeOption?: string;
    rate?: string;
    label?: string;
    loading?: string;
}
interface CurrencySelectorProps {
    /** Available currencies to display. */
    currencies: CurrencyCode[];
    /** Currently selected currency. */
    currentCurrency?: CurrencyCode;
    /** Called when a currency is selected. */
    onCurrencyChange?: (currency: CurrencyCode) => void;
    /** Show the exchange rate next to each currency. Requires `baseCurrency`. */
    showRate?: boolean;
    /** Base currency used for rate display. */
    baseCurrency?: CurrencyCode;
    /** Custom currency option renderer. */
    renderCurrency?: (currency: CurrencyCode, isActive: boolean, rate: FxRateResponse | null) => React__default.ReactNode;
    className?: string;
    classNames?: CurrencySelectorClassNames;
}
/**
 * CurrencySelector — currency switcher for international customers.
 *
 * Renders selectable currency options with optional exchange rate display.
 * Returns `null` when there is only one currency (no selector needed).
 */
declare function CurrencySelector({ currencies, currentCurrency, onCurrencyChange, showRate, baseCurrency, renderCurrency, className, classNames, }: CurrencySelectorProps): React__default.ReactElement | null;

/** Where this bubble sits in a run of consecutive same-sender messages. */
type GroupPosition = "single" | "first" | "middle" | "last";
/** The customer message's journey, rendered as ticks inside the bubble. */
type DeliveryState = "sending" | "delivered" | "seen";
declare function sameDay(a: string, b: string): boolean;
declare function dayLabel(at: string): string;
declare function proseOf(content: string): string;
interface ChatTimeline {
    bubbles: ChatMessage[];
    reactionsByTarget: Map<string, ChatMessage[]>;
    firstUnreadId: string | undefined;
    unreadOnOpen: number;
    firstAgentMessageId: string | undefined;
}
interface ChatTimelineOptions {
    /** Read watermark captured when the surface last closed — anchors the unread seam. */
    readAt?: string | null;
    /** Whether this surface can draw ```genui programs; without it a program-only
     * turn has nothing to show and must not render a phantom bubble. */
    rendersPrograms?: boolean;
}
/**
 * One assembly for every chat surface: reactions fold onto their targets, a
 * message with nothing to show is dropped (an invisible bubble still breaks
 * the sender run on both sides), and the unread seam anchors where the
 * reader stopped, staying put as reads move.
 */
declare function chatTimeline(messages: ChatMessage[], options?: ChatTimelineOptions): ChatTimeline;
/**
 * A run is consecutive messages from the same voice, unbroken by a seam —
 * they read as one utterance, so they share an avatar and only the last one
 * gets a tail.
 */
declare function groupPosition(timeline: ChatTimeline, index: number): GroupPosition;
/**
 * Solid ticks only once a person has been in the thread; AI-only never
 * claims "seen" — it proves processing, not attention.
 */
declare function deliveryState(message: ChatMessage, timeline: ChatTimeline, seenAt: string | null, isOptimistic: (message: Pick<ChatMessage, "id">) => boolean): DeliveryState | undefined;

/** Curved bubble tail, continuous with the bubble edge. Render inside a
 * `relative` bubble whose tail-side bottom corner is squared. */
declare function BubbleTail({ isCustomer }: {
    isCustomer: boolean;
}): react_jsx_runtime.JSX.Element;
interface MessageBubbleProps {
    message: ChatMessage;
    reactions?: ChatMessage[];
    businessName: string;
    group?: GroupPosition;
    delivery?: DeliveryState;
    onReply: (message: ChatMessage) => void;
    /** Long-press / context-menu path — the surface's menu, if it has one. */
    onLongPress?: (message: ChatMessage) => void;
    /** The run avatar next to business bubbles (shown on the run's last bubble). */
    avatar?: ReactNode;
    /** Absolutely-positioned extras inside the row: hover rails, open menus. */
    overlay?: ReactNode;
    /** Structured cards under the bubble (metadata.cards) — surface-specific visuals. */
    renderCards?: (message: ChatMessage) => ReactNode;
    /** ```genui program renderer — surface-specific catalog and actions. */
    renderProgram?: (source: string) => ReactNode;
    /** Quote-tap fallback when the original is above the loaded window. */
    onQuoteMiss?: () => Promise<boolean>;
}
declare const MessageBubble: React__default.MemoExoticComponent<({ message, reactions, businessName, group, delivery, onReply, onLongPress, avatar, overlay, renderCards, renderProgram, onQuoteMiss, }: MessageBubbleProps) => react_jsx_runtime.JSX.Element>;

/** Conversation seams (Paper board 30): dates float as white chips, events
 * (handoff, person joined) sit in a hairline rule, and the unread marker gets
 * the emerald treatment so it's findable at a glance. */
declare function Seam({ label, variant, }: {
    label: string;
    variant?: "chip" | "line" | "unread";
}): react_jsx_runtime.JSX.Element;

declare function QuoteBlock({ quote, inCustomerBubble, businessName, onMissing, }: {
    quote: ChatReplyContext;
    inCustomerBubble: boolean;
    businessName: string;
    onMissing?: () => Promise<boolean>;
}): react_jsx_runtime.JSX.Element;

declare const SWIPE_COMMIT_PX = 48;
/** Leftward travel of the bubble: 1:1 to the commit threshold, rubber-banded past it. */
declare function swipeTravel(distance: number): number;
declare function swipeCommitted(distance: number): boolean;
declare function swipeProgress(distance: number): number;
interface SwipeReplyOptions {
    onReply: () => void;
    onLongPress: () => void;
}
/**
 * Swipe-to-reply on a message row. Swipe LEFT on purpose: a rightward
 * gesture near the screen edge is the browser's back-navigation on iOS.
 * The gesture only arms on clear horizontal intent, so vertical scrolling
 * through history never fights it; long-press is the accessibility and
 * reduced-motion path.
 *
 * Movement is written straight to the DOM (no per-frame renders): the row
 * element tracks the finger 1:1 and the glyph fades in with progress.
 */
declare function useSwipeReply({ onReply, onLongPress }: SwipeReplyOptions): {
    rowRef: React$1.RefObject<HTMLDivElement | null>;
    glyphRef: React$1.RefObject<HTMLSpanElement | null>;
    handlers: {
        onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
        onPointerMove: (event: PointerEvent<HTMLDivElement>) => void;
        onPointerUp: (event: PointerEvent<HTMLDivElement>) => void;
        onPointerCancel: (event: PointerEvent<HTMLDivElement>) => void;
        onClickCapture: (event: MouseEvent<HTMLDivElement>) => void;
    };
};

/** One source of truth for the reduced-motion preference — scrolls and
 * gesture animation downgrade together. */
declare function prefersReducedMotion(): boolean;
declare function scrollBehavior(): ScrollBehavior;

/**
 * Discriminated union representing every value that can appear in an
 * openui-lang expression. The `k` field is the discriminant.
 *
 * Literal & structural nodes:
 * - `Comp`       — a component call: `Header("Hello", "Subtitle")`
 * - `Str`        — a string literal: `"hello"`
 * - `Num`        — a number literal: `42` or `3.14`
 * - `Bool`       — a boolean literal: `true` or `false`
 * - `Null`       — the null literal
 * - `Arr`        — an array: `[a, b, c]`
 * - `Obj`        — an object: `{ key: value }`
 * - `Ref`        — a reference to another statement: `myTable`
 * - `Ph`         — a placeholder for an unresolvable reference
 *
 * Reactive & expression nodes:
 * - `StateRef`   — a reactive state variable reference: `$count`
 * - `RuntimeRef` — a reference resolved at runtime (e.g. Query results)
 * - `BinOp`      — a binary operation: `a + b`, `x == y`
 * - `UnaryOp`    — a unary operation: `!flag`
 * - `Ternary`    — a conditional expression: `cond ? a : b`
 * - `Member`     — dot member access: `obj.field`
 * - `Index`      — bracket index access: `arr[0]`
 * - `Assign`     — state assignment: `$count = $count + 1`
 */
type ASTNode = {
    k: "Comp";
    name: string;
    args: ASTNode[];
    mappedProps?: Record<string, ASTNode>;
} | {
    k: "Str";
    v: string;
} | {
    k: "Num";
    v: number;
} | {
    k: "Bool";
    v: boolean;
} | {
    k: "Null";
} | {
    k: "Arr";
    els: ASTNode[];
} | {
    k: "Obj";
    entries: [string, ASTNode][];
} | {
    k: "Ref";
    n: string;
} | {
    k: "Ph";
    n: string;
} | {
    k: "StateRef";
    n: string;
} | {
    k: "RuntimeRef";
    n: string;
    refType: "query" | "mutation";
} | {
    k: "BinOp";
    op: string;
    left: ASTNode;
    right: ASTNode;
} | {
    k: "UnaryOp";
    op: string;
    operand: ASTNode;
} | {
    k: "Ternary";
    cond: ASTNode;
    then: ASTNode;
    else: ASTNode;
} | {
    k: "Member";
    obj: ASTNode;
    field: string;
} | {
    k: "Index";
    obj: ASTNode;
    index: ASTNode;
} | {
    k: "Assign";
    target: string;
    value: ASTNode;
};

interface ParamDef {
    /** Parameter name, e.g. "title", "columns". */
    name: string;
    /** Whether the parameter is required by the component. */
    required: boolean;
    /** Default value from JSON Schema — used when the required field is missing/null. */
    defaultValue?: unknown;
}
/** Internal parameter map for positional-arg to named-prop mapping. */
type ParamMap = Map<string, {
    params: ParamDef[];
}>;
/**
 * A fully resolved component node from the parser.
 *
 * The parser converts openui-lang text into a tree of these nodes.
 * Each node represents one component invocation with its positional
 * arguments mapped into named `props` via the library's Zod key order.
 */
interface ElementNode {
    type: "element";
    /** Source variable name (e.g. "header" from `header = TextContent(...)`). Undefined for inline components. */
    statementId?: string;
    /** Component name as defined in the library (e.g. "Table", "BarChart"). */
    typeName: string;
    /** Named props produced by positional-to-named mapping in the parser. */
    props: Record<string, unknown>;
    /**
     * True when the parser hasn't received all tokens for this node yet
     * (streaming in progress).
     */
    partial: boolean;
    /**
     * False when all props are static literals — evaluation can be skipped.
     * Undefined is treated as true (dynamic) for backward compatibility.
     */
    hasDynamicProps?: boolean;
}
/**
 * Validation error codes for schema-related issues.
 */
type ValidationErrorCode = "missing-required" | "null-required" | "unknown-component" | "inline-reserved" | "excess-args";
/**
 * A prop validation error. Components with missing required props are
 * dropped from the output tree and errors are recorded here.
 */
interface ValidationError {
    /** Machine-readable error code. */
    code: ValidationErrorCode;
    /** Component type name, e.g. "Header", "BarChart". */
    component: string;
    /** JSON Pointer path within the props object, e.g. "/title", "". */
    path: string;
    /** Human-readable error message. */
    message: string;
    /** Statement name that triggered the error (e.g. "header", "chart"). */
    statementId?: string;
}
/**
 * Extracted info about a Query() call from the parsed program.
 */
interface QueryStatementInfo {
    /** Statement name that holds this query (e.g. "metrics"). */
    statementId: string;
    /** First arg AST — the tool name (should evaluate to a string). */
    toolAST: ASTNode | null;
    /** Second arg AST — the arguments object (may contain $var refs). */
    argsAST: ASTNode | null;
    /** Third arg AST — default data returned before fetch resolves. */
    defaultsAST: ASTNode | null;
    /** Fourth arg AST — refresh interval in seconds. */
    refreshAST: ASTNode | null;
    /** Pre-computed $variable deps from argsAST (extracted at parse time). */
    deps?: string[];
    /** False while the Query() call is still being streamed. */
    complete: boolean;
}
/**
 * Extracted info about a Mutation() call from the parsed program.
 */
interface MutationStatementInfo {
    /** Statement name that holds this mutation (e.g. "createResult"). */
    statementId: string;
    /** First arg AST — the tool name (should evaluate to a string). */
    toolAST: ASTNode | null;
    /** Second arg AST — the arguments object (may contain $var refs). */
    argsAST: ASTNode | null;
}
/**
 * The output of a single `parser.parse(text)` call.
 *
 * During streaming, each chunk produces a new ParseResult as the
 * accumulated text is re-parsed. The `root` progressively resolves
 * from null → partial tree → complete tree.
 */
interface ParseResult {
    /** The root ElementNode (typically a Root component), or null if parsing hasn't produced one yet. */
    root: ElementNode | null;
    meta: {
        /** True if the parser detected truncated/incomplete input. */
        incomplete: boolean;
        /** Names of references used but not yet defined (dropped as null in output). */
        unresolved: string[];
        /** Names of value statements defined but not reachable from root. Excludes $state, Query, and Mutation declarations. */
        orphaned: string[];
        /** Total number of `identifier = Expression` statements parsed. */
        statementCount: number;
        /**
         * Prop validation errors. Components with missing required props are
         * redacted (dropped as null) and listed here.
         */
        errors: ValidationError[];
    };
    /** $variable declarations — maps "$varName" to its materialized default value. */
    stateDeclarations: Record<string, unknown>;
    /** Extracted Query() calls with their positional args as AST nodes. */
    queryStatements: QueryStatementInfo[];
    /** Extracted Mutation() calls with their positional args as AST nodes. */
    mutationStatements: MutationStatementInfo[];
}

/** Fired when a Button carries a plain "action:name" string. */
interface GenUIActionEvent {
    action: string;
    label: string;
}
interface GenUIRenderContext {
    /** Render any prop value (child element, array of children, or nothing). */
    render: (value: unknown) => ReactNode;
    onAction: (event: GenUIActionEvent) => void;
    isStreaming: boolean;
}
type GenUIComponentRenderer = (props: {
    node: ElementNode;
    ctx: GenUIRenderContext;
}) => ReactNode;
/** Per-surface visual implementations, keyed by vocabulary component name. */
type GenUIComponentMap = Record<string, GenUIComponentRenderer>;
interface GenUITelemetryEvent {
    kind: "unknown-component" | "dropped-node";
    typeName: string;
}
interface GenUIViewProps {
    root: ElementNode | null;
    components: GenUIComponentMap;
    onAction?: (event: GenUIActionEvent) => void;
    isStreaming?: boolean;
    onTelemetry?: (event: GenUITelemetryEvent) => void;
    /** Shown while streaming before the first complete root arrives. */
    placeholder?: ReactNode;
}
/**
 * Headless GenUI renderer: walks a parsed program tree and delegates every
 * node to the surface's component map (the same split as iOS, where the
 * registry vocabulary is shared and each surface owns its views).
 */
declare function GenUIView({ root, components, onAction, isStreaming, onTelemetry, placeholder, }: GenUIViewProps): ReactNode;

/**
 * Host-neutral register for the support GenUI dialect: the same vocabulary
 * lite and desk render, styled with standard theme tokens only. Colors that
 * exist solely in lite's theme (pending, the wash tints) resolve through
 * var chains so any shadcn-tokened host degrades gracefully.
 */
declare const CHAT_ACTION_VIEW_PRODUCT = "view_product";
declare const CHAT_ACTION_VIEW_ORDER = "view_order";
/** `chat:view_product:prd_1` → `{ verb: "view_product", id: "prd_1" }`. */
declare function parseChatAction(action: string): {
    verb: string;
    id: string;
} | null;
declare const CHAT_GENUI_COMPONENTS: GenUIComponentMap;
interface ChatKitProgramProps {
    source: string;
    onAction?: (event: GenUIActionEvent) => void;
}
/** Renders one fenced program from a bot reply in the host-neutral register. */
declare function ChatKitProgram({ source, onAction }: ChatKitProgramProps): react_jsx_runtime.JSX.Element | null;
interface ChatReplyCardsProps {
    message: ChatMessage;
    currency?: string | null;
    onAction?: (event: GenUIActionEvent) => void;
}
/** Structured cards from `metadata.cards`, tappable when the host wires actions. */
declare function ChatReplyCards({ message, currency, onAction }: ChatReplyCardsProps): react_jsx_runtime.JSX.Element | null;

interface ChatWidgetClassNames {
    root?: string;
    bubble?: string;
    panel?: string;
    header?: string;
    messages?: string;
    input?: string;
    welcome?: string;
}
interface ChatWidgetProps {
    client?: CimplifyClient;
    /** Business display name shown in the header */
    businessName?: string;
    /** Greeting text on the welcome screen */
    greeting?: string;
    /** Subtitle on the welcome screen */
    subtitle?: string;
    /** Conversation starters */
    starters?: ChatWidgetStarter[];
    /** Input placeholder */
    placeholder?: string;
    /** Position of the bubble */
    position?: "bottom-right" | "bottom-left";
    /** Start with the panel open */
    defaultOpen?: boolean;
    /** Poll interval in ms (default: 3000) */
    pollInterval?: number;
    /** Currency for structured product cards (e.g. "GHS"). */
    currency?: string;
    /**
     * Receives taps on GenUI buttons and structured cards
     * (`chat:view_product:{id}`, `chat:view_order:{id}`). Without it, cards
     * render read-only and program buttons no-op.
     */
    onGenUIAction?: (event: GenUIActionEvent) => void;
    className?: string;
    classNames?: ChatWidgetClassNames;
}
declare function ChatWidget({ client: clientProp, businessName: businessNameProp, greeting, subtitle, starters, placeholder, position, defaultOpen, pollInterval, currency: currencyProp, onGenUIAction, className, classNames, }: ChatWidgetProps): react_jsx_runtime.JSX.Element;

interface ChatMarkdownProps {
    text: string;
    className?: string;
    /** True while this message is still receiving tokens — engages streamdown's
     * incomplete-markdown smoothing on capable browsers. */
    streaming?: boolean;
}
declare const ChatMarkdown: React__default.MemoExoticComponent<({ text, className, streaming, }: ChatMarkdownProps) => react_jsx_runtime.JSX.Element>;

declare function optimisticId(clientId: string): string;
declare function isOptimistic(message: Pick<ChatMessage, "id">): boolean;
interface PartitionedMessages {
    bubbles: ChatMessage[];
    reactionsByTarget: Map<string, ChatMessage[]>;
}
/**
 * Reaction rows are references, not bubbles: group each onto its target via
 * the server-resolved `reply_to`, and drop any whose target isn't loaded —
 * an emoji must never render as a standalone message.
 */
declare function partitionMessages(messages: ChatMessage[]): PartitionedMessages;

/**
 * The Cimplify GenUI vocabulary — the component names, ordered params, and
 * descriptions the model is allowed to emit. This MUST stay in lockstep with
 * the iOS Swift registry (packages/ios/.../Render/GenUICimplifyLibrary.swift):
 * the capability-manifest fingerprint is the cross-surface contract, and the
 * fingerprint-parity tests on both sides fail when either copy drifts.
 *
 * Visual implementations are per-surface (SwiftUI on iOS, React maps on
 * desk/lite); only the vocabulary lives here.
 */
interface GenUIParamDef {
    name: string;
    required?: boolean;
}
interface GenUIComponentDef {
    name: string;
    description: string;
    params: GenUIParamDef[];
}
interface GenUIRegistry {
    version: string;
    components: GenUIComponentDef[];
}
declare const CIMPLIFY_GENUI_REGISTRY: GenUIRegistry;

/** Parser catalog derived from the vocabulary registry — positional args map
 * to named props in this exact order, so it must never be hand-built. */
declare function genUICatalog(registry: GenUIRegistry): ParamMap;

/** One renderable slice of a message, in source order. */
type GenUISegment = {
    kind: "prose";
    text: string;
} | {
    kind: "program";
    source: string;
};
/**
 * Split message content into prose and ```genui program segments. An
 * unterminated fence (streaming, truncation) is treated as a program to its
 * end — the parser's last-good retention handles the partial tail.
 */
declare function splitGenUIContent(content: string): GenUISegment[];
/**
 * One-line human preview of a message: prose only, GenUI fences elided.
 * Shared by reply quotes, composer reply bars, and list snippets — and
 * mirrored server-side for the customer wire's `reply_to.preview`.
 */
declare function messagePreview(content: string, max?: number): string;

/**
 * Parse a complete openui-lang string in one pass.
 *
 * @param input  - Full openui-lang source text (may be partial/streaming)
 * @param cat    - Param map for positional-arg → named-prop mapping
 * @returns      ParseResult with root ElementNode (or null) and metadata
 */
declare function parse(input: string, cat: ParamMap, rootName?: string): ParseResult;

interface GenUIProgramState {
    result: ParseResult;
    /** Last parse that produced a root — retained through transiently broken
     * streaming states so the surface never blanks mid-stream. */
    root: ElementNode | null;
}
/**
 * Parse a (possibly still-streaming) GenUI program. Pass the full accumulated
 * text each render — the stream parser diffs internally and re-parses only
 * the trailing partial statement, and resets itself if the text was replaced
 * rather than appended.
 */
declare function useGenUIProgram(text: string, catalog: ParamMap): GenUIProgramState;

/**
 * Capability manifest + fingerprint — the cross-surface vocabulary contract.
 * The wire bytes must match the Swift side (GenUIPrompt.swift) exactly:
 * Swift encodes with JSONEncoder([.sortedKeys]), which emits compact JSON,
 * sorts object keys at every level, and escapes "/" as "\/". The fingerprint
 * is the first 16 hex chars of SHA-256 over those bytes. Parity is pinned by
 * tests on both sides; if you change either registry, both fail together.
 */
interface GenUIManifestParam {
    name: string;
    required: boolean;
}
interface GenUIManifestComponent {
    name: string;
    description: string;
    params: GenUIManifestParam[];
}
interface GenUICapabilityManifest {
    version: string;
    components: GenUIManifestComponent[];
}
declare function genUIManifest(registry: GenUIRegistry): GenUICapabilityManifest;
/** Swift-JSONEncoder-equivalent bytes for the manifest. */
declare function genUIManifestJson(manifest: GenUICapabilityManifest): string;
/** First 16 hex chars of SHA-256 over the canonical manifest bytes. */
declare function genUIFingerprint(manifest: GenUICapabilityManifest): Promise<string>;

export { AccommodationCard, AccountContent, type AccountContentProps, AccountDashboardPage, type AccountDashboardPageProps, AccountHero, type AccountHeroProps, AccountIdentityStrip, type AccountIdentityStripProps, AccountLineItem, type AccountLineItemData, type AccountLineItemProps, AccountLineItems, type AccountLineItemsProps, AccountNav, type AccountNavProps, AccountOrderDetailPage, type AccountOrderDetailPageProps, AccountOrderView, type AccountOrderViewProps, AccountOrdersPage, type AccountOrdersPageProps, type AccountPageBaseProps, AccountShell, type AccountShellProps, AccountSidebar, type AccountSidebarProps, AccountSignedOutPrompt, type AccountSignedOutPromptProps, AccountSubscriptionDetailPage, type AccountSubscriptionDetailPageProps, AccountSubscriptionsPage, type AccountSubscriptionsPageProps, Ad, AdPosition, type AdProps, AdProvider, AdSlot, AddOnSelector, type AddOnSelectorClassNames, type AddOnSelectorProps, type AddToCartOptions, AddressAutocomplete, type AddressAutocompleteClassNames, type AddressAutocompleteProps, AddressElement, AuthElement, AvailabilityBadge, type AvailabilityBadgeClassNames, type AvailabilityBadgeProps, BackLink, type BackLinkProps, BillingPlanSelector, type BillingPlanSelectorClassNames, type BillingPlanSelectorProps, BookingCard, type BookingCardClassNames, type BookingCardProps, BookingList, type BookingListClassNames, type BookingListProps, BookingPage, type BookingPageClassNames, type BookingPageProps, BookingSummary, type BookingSummaryClassNames, type BookingSummaryProps, BookingsPage, type BookingsPageClassNames, type BookingsPageProps, type BoundaryLabels, BoxIcon24, BubbleTail, BundleProductCard, BundleProductLayout, BundleSelector, type BundleSelectorClassNames, type BundleSelectorProps, Button, type ButtonProps, CHAT_ACTION_VIEW_ORDER, CHAT_ACTION_VIEW_PRODUCT, CHAT_GENUI_COMPONENTS, CIMPLIFY_GENUI_REGISTRY, CardImage, type CardLayoutProps, CardShell, CardVariant, type CartAddOnOptionSelection, CartDrawer, type CartDrawerProps, CartDrawerProvider, type CartLayoutProps, CartPage, type CartPageClassNames, type CartPageProps, CartSummary, type CartSummaryClassNames, type CartSummaryProps, CartTemplate, type CartVariantSelection, CatalogueCollectionLayout, type CatalogueLayoutProps, CataloguePage, type CataloguePageClassNames, type CataloguePageProps, CatalogueTemplate, CategoryFilter, type CategoryFilterClassNames, type CategoryFilterProps, CategoryGrid, type CategoryGridClassNames, type CategoryGridProps, ChatKitProgram, type ChatKitProgramProps, ChatMarkdown, type ChatMarkdownProps, ChatReplyCards, type ChatReplyCardsProps, type ChatTimeline, type ChatTimelineOptions, ChatWidget, type ChatWidgetClassNames, type ChatWidgetProps, CheckIcon, CheckoutPage, type CheckoutPageClassNames, type CheckoutPageProps, CimplifyCheckout, type CimplifyCheckoutProps, type CimplifyClientContextValue, type CimplifyClientSession, type CimplifyContextValue, type CimplifyLinkComponent, type CimplifyLinkProps, CimplifyProvider, type CimplifyProviderProps, CimplifySignInButton, type CimplifySignInButtonProps, CimplifyUserButton, type CimplifyUserButtonProps, type CollectionLayoutProps, CollectionPage, type CollectionPageClassNames, type CollectionPageProps, CollectionTemplate, CompactCartLayout, CompactCatalogueLayout, CompactSearchLayout, CompactServiceCard, CompositeProductCard, CompositeProductLayout, CompositeSelector, type CompositeSelectorClassNames, type CompositeSelectorProps, ContextCard, type ContextCardProps, type ContextRow, ContinuityCard, type ContinuityCardProps, CurrencySelector, type CurrencySelectorClassNames, type CurrencySelectorProps, CustomAttributesTable, type CustomerInput, CustomerInputFields, type CustomerInputFieldsClassNames, type CustomerInputFieldsProps, type CustomerInputType, DashboardIcon, DashboardIcon20, DatePicker, type DatePickerClassNames, type DatePickerProps, DateSlotPicker, type DateSlotPickerClassNames, type DateSlotPickerProps, DealBanner, type DealBannerClassNames, type DealBannerProps, DealsPage, type DealsPageClassNames, type DealsPageProps, DefaultCartLayout, DefaultCatalogueLayout, DefaultCollectionLayout, DefaultProductLayout, DefaultSearchLayout, DeliveryEstimate, type DeliveryEstimateClassNames, type DeliveryEstimateProps, type DeliveryLive, type DeliveryRider, type DeliveryState, DeliveryTracker, type DeliveryTrackerProps, DeliveryTruckIcon, type DigitalFulfillment, DigitalProductCard, DigitalProductLayout, DiscountInput, type DiscountInputClassNames, type DiscountInputProps, ElementsProvider, EmptyState, type EmptyStateProps, ErrorState, type ErrorStateProps, FeaturedCollectionLayout, type FilterTabItem, FilterTabs, type FilterTabsProps, FoodProductCard, FoodProductLayout, type GenUIActionEvent, type GenUICapabilityManifest, type GenUIComponentDef, type GenUIComponentMap, type GenUIComponentRenderer, type ElementNode as GenUIElementNode, type GenUIParamDef, type ParseResult as GenUIParseResult, type GenUIProgramState, type GenUIRegistry, type GenUIRenderContext, type GenUISegment, type GenUITelemetryEvent, GenUIView, type GroupPosition, HappeningCard, type HappeningCardProps, type HappeningPaneData, IdentityIcon, IdentityOfframp, type IdentityOfframpProps, type IdentitySummary, InventoryBadge, ItemsCard, type ItemsCardProps, LeaseServiceCard, LineItemDetails, type LineItemSemanticKind, type LineScheduling, type LineSelection, type LineStateTone, LocationPicker, type LocationPickerClassNames, type LocationPickerProps, MediaGallery, type MediaGalleryProps, type MediaItem, MessageBubble, type MessageBubbleProps, MetadataStringList, MobileAccountShell, type MobileAccountShellProps, MobileBackButton, MobileMoreButton, MobileTabBar, type MobileTabBarProps, type NavItem, NextDeliveryCard, type NextDeliveryCardProps, OrderDetailHeader, type OrderDetailHeaderProps, OrderDetailMetaPipe, OrderDetailPage, type OrderDetailPageClassNames, type OrderDetailPageProps, OrderHistory, type OrderHistoryClassNames, OrderHistoryPage, type OrderHistoryPageClassNames, type OrderHistoryPageProps, type OrderHistoryProps, type OrderItemData, OrderList, type OrderListProps, OrderRow, type OrderRowData, type OrderRowProps, type OrderRowStatus, type OrderStatusTone, OrderSummary, type OrderSummaryClassNames, type OrderSummaryProps, OrderTimeline, type OrderTimelineProps, OrderTotals, type OrderTotalsProps, type OrderViewDelivery, type OrderViewPayment, type OrderViewPaymentRow, OrdersIcon, OrdersIcon20, OvenIcon, PackageIcon, type PartitionedMessages, PaymentElement, type PrefetchMode, type PrefetchOptions, Price, type PriceProps, PriceRange, type PriceRangeProps, ProductCard, type ProductCardClassNames, type ProductCardProps, ProductCustomizer, type ProductCustomizerClassNames, type ProductCustomizerProps, ProductGrid, type ProductGridClassNames, type ProductGridProps, ProductImageGallery, type ProductImageGalleryProps, type ProductLayoutProps, ProductModel3D, type ProductModel3DProps, ProductPage, type ProductPageClassNames, type ProductPageProps, ProductSheet, type ProductSheetClassNames, type ProductSheetProps, ProductTemplate, PropertiesTable, QuantitySelector, type QuantitySelectorClassNames, type QuantitySelectorProps, QuickAddButton, QuoteBlock, RecentlyViewed, type RecentlyViewedClassNames, type RecentlyViewedProps, RecommendationCarousel, type RecommendationCarouselClassNames, type RecommendationCarouselProps, RelatedProductsSection, RentalServiceCard, type Resource, ResourcePicker, type ResourcePickerClassNames, type ResourcePickerProps, RetailProductCard, RichText, type RichTextProps, SWIPE_COMMIT_PX, SaleBadge, type SaleBadgeClassNames, type SaleBadgeProps, SalePrice, type SalePriceClassNames, type SalePriceProps, SaleTeaser, type SaleTeaserProps, ScheduleServiceCard, Seam, SearchInput, type SearchInputClassNames, type SearchInputProps, type SearchLayoutProps, SearchPage, type SearchPageClassNames, type SearchPageProps, SearchTemplate, Section, SectionMore, type SectionMoreProps, type SectionProps, type ServiceCardLayoutProps, ServiceProductLayout, SessionMessageBanner, type SessionMessageBannerClassNames, type SessionMessageBannerProps, SignOutIcon, Skeleton, type SkeletonProps, SlotPicker, type SlotPickerClassNames, type SlotPickerProps, SoldOutOverlay, StaffPicker, type StaffPickerClassNames, type StaffPickerProps, StandardServiceCard, Status, type StatusProps, StoreNav, type StoreNavClassNames, type StoreNavProps, StoreVideo, type StoreVideoProps, SubscriptionCard, SubscriptionList, type SubscriptionListProps, SubscriptionRow, type SubscriptionRowData, type SubscriptionRowProps, SubscriptionsIcon, SubscriptionsIcon20, TagPills, TimePicker, type TimePickerClassNames, type TimePickerProps, type TimelineStep, type ToAccountOrderViewOptions, Toast, type ToastProps, type TotalsData, TwoColumnGrid, type UseActivityStateOptions, type UseActivityStateResult, type UseAttributeDefinitionsOptions, type UseAttributeDefinitionsResult, type UseAvailableSlotsOptions, type UseAvailableSlotsResult, type UseBillingPlansOptions, type UseBillingPlansResult, type UseBookingsOptions, type UseBookingsResult, type UseBootstrapOptions, type UseBootstrapResult, type UseBundlesOptions, type UseBundlesResult, type UseCartItem, type UseCartOptions, type UseCartResult, type UseCategoriesOptions, type UseCategoriesResult, type UseChatOptions, type UseChatResult, type UseCimplifySessionOptions, type UseCimplifySessionResult, type UseCollectionOptions, type UseCollectionResult, type UseCollectionsOptions, type UseCollectionsResult, type UseDealsOptions, type UseDealsResult, type UseDeliveryFeeOptions, type UseDeliveryFeeResult, type UseFxRateOptions, type UseFxRateResult, type UseLocationsOptions, type UseLocationsResult, type UseOrderOptions, type UseOrderResult, type UseOrdersOptions, type UseOrdersResult, type UseProductAvailabilityOptions, type UseProductAvailabilityResult, type UseProductDealsOptions, type UseProductDealsResult, type UseProductOptions, type UseProductPriceInput, type UseProductPriceResult, type UseProductResult, type UseProductSchedulesOptions, type UseProductSchedulesResult, type UseProductsOnSaleOptions, type UseProductsOnSaleResult, type UseProductsOptions, type UseProductsResult, type UsePropertyFacetsOptions, type UsePropertyFacetsResult, type UseQuoteInput, type UseQuoteOptions, type UseQuoteResult, type UseRecommendationsOptions, type UseRecommendationsResult, type UseSearchOptions, type UseSearchResult, type UseServiceAvailabilityOptions, type UseServiceAvailabilityResult, type UseServicesOptions, type UseServicesResult, type UseStoreCreditOptions, type UseStoreCreditResult, type UseTaxonomiesOptions, type UseTaxonomiesResult, type UseTaxonomyOptions, type UseTaxonomyPathOptions, type UseTaxonomyPathResult, type UseTaxonomyResult, type UseValidateDiscountOptions, type UseValidateDiscountResult, type UseVariantSelectorOptions, type UseVariantSelectorResult, type UserButtonLink, VariantSelector, type VariantSelectorClassNames, type VariantSelectorProps, VolumePricing, type VolumePricingClassNames, type VolumePricingProps, WelcomeCard, type WelcomeCardProps, WholesaleProductCard, WholesaleProductLayout, WishlistButton, chatTimeline, clearOrdersCache, cn, createPlacesSessionToken, dayLabel, defaultBoundaryKind, deliveryState, genUICatalog, genUIFingerprint, genUIManifest, genUIManifestJson, getBoundaryLabels, groupPosition, isImageAttachment, isOptimistic, isTerminalOrderStatus, messagePreview, optimisticId, parseChatAction, parse as parseGenUIProgram, partitionMessages, prefersReducedMotion, prefetchProduct, prefetchProducts, proseOf, resolveBoundaryKind, roomToResource, safeAttachmentUrl, sameDay, sanitizeRichTextHtml, scrollBehavior, splitGenUIContent, stripHtmlToText, swipeCommitted, swipeProgress, swipeTravel, toAccountLineItem, toAccountLineItems, toAccountOrderView, useActivityState, useAds, useAttributeDefinitions, useAvailableSlots, useBillingPlans, useBookings, useBootstrap, useBundles, useCart, useCartDrawer, useCategories, useChat, useCheckout, useCimplify, useCimplifyClient, useCimplifySession, useCollection, useCollections, useDeals, useDeliveryFee, useDeliveryOptions, useElements, useElementsReady, useFxRate, useGenUIProgram, useLocations, useOptionalCimplify, useOrder, useOrders, useProduct, useProductAvailability, useProductDeals, useProductPrice, useProductSchedules, useProducts, useProductsOnSale, usePropertyFacets, useQuote, useRecommendations, useSearch, useServiceAvailability, useServices, useStoreCredit, useSubscription, useSubscriptions, useSwipeReply, useTaxonomies, useTaxonomy, useTaxonomyPath, useValidateDiscount, useVariantSelector };