@zorgo/next 1.1.7 → 2.0.0

package/dist/index.d.ts

@@ -1,9 +1,80 @@
 import * as _stripe_stripe_js from '@stripe/stripe-js';
 import { StripeElementsOptions } from '@stripe/stripe-js';
-import * as React from 'react';
-import React__default, { RefObject } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { RefObject, SVGProps } from 'react';
 import { z } from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * How the section picker draws itself. Closed set — each value needs a renderer,
+ * so adding one is a code change (and an `alter type portion_geometry add value`).
+ *
+ * Section order is fixed per geometry, and consecutive indices must be spatially
+ * adjacent so any divisor of the division count partitions cleanly (sections 1–3
+ * of 6 are exactly section 1 of 2). Without that, switching a customer from
+ * sixths to halves has no defined answer.
+ *
+ * - `radial` — contiguous arcs from 12 o'clock, counter-clockwise
+ * - `grid`   — column-major: down the left column, then the next column
+ * - `linear` — one end to the other
+ * - `count`  — equal shares of a countable quantity, no geometry
+ */
+declare const PortionGeometrySchema: z.ZodEnum<{
+    radial: "radial";
+    grid: "grid";
+    linear: "linear";
+    count: "count";
+}>;
+type PortionGeometry = z.infer<typeof PortionGeometrySchema>;
+/** A row of `portion_schemes` — a franchise-owned, franchise-named menu entity. */
+declare const PortionSchemeSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    franchise_id: z.ZodNumber;
+    geometry: z.ZodEnum<{
+        radial: "radial";
+        grid: "grid";
+        linear: "linear";
+        count: "count";
+    }>;
+    name: z.ZodString;
+    min_divisions: z.ZodDefault<z.ZodNumber>;
+    max_divisions: z.ZodNumber;
+}, z.core.$strip>;
+type PortionScheme = z.infer<typeof PortionSchemeSchema>;
+
+declare const EventSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    created_at: z.ZodString;
+    severity: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>;
+    event_name: z.ZodString;
+    source: z.ZodEnum<{
+        pos: "pos";
+        kds: "kds";
+        kiosk: "kiosk";
+        restaurant_site: "restaurant_site";
+        developer_dashboard: "developer_dashboard";
+        zorgo_site: "zorgo_site";
+        backend: "backend";
+    }>;
+    service: z.ZodNullable<z.ZodString>;
+    device_id: z.ZodNullable<z.ZodNumber>;
+    session_id: z.ZodNullable<z.ZodString>;
+    request_id: z.ZodNullable<z.ZodString>;
+    franchise_id: z.ZodNullable<z.ZodNumber>;
+    location_id: z.ZodNullable<z.ZodNumber>;
+    user_id: z.ZodNullable<z.ZodString>;
+    anonymous_id: z.ZodNullable<z.ZodString>;
+    customer_id: z.ZodNullable<z.ZodNumber>;
+    order_id: z.ZodNullable<z.ZodNumber>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    stack_trace: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type EventRow = z.infer<typeof EventSchema>;
 
 type LocationStatus = "active" | "permanently_closed";
 interface Location {
@@ -11,6 +82,8 @@ interface Location {
     franchise_id: number;
     name: string;
     address?: string;
+    /** Public storefront number, as staff typed it. Display only. */
+    phone?: string;
     force_close?: boolean;
     status?: LocationStatus | null;
     lat?: number | null;
@@ -44,6 +117,7 @@ interface Category {
     name: string;
     is_catering?: boolean;
     rules: Rule[];
+    sort_index?: number | null;
     active_promo_id?: number;
 }
 interface ItemVariant {
@@ -53,19 +127,32 @@ interface ItemVariant {
     components?: Component[];
     base_item_id?: number;
     rules?: Rule[];
+    portion_scheme_id?: number | null;
+    portion_scheme?: PortionScheme | null;
+    sort_index?: number | null;
     display_price?: number;
     active_promo_id?: number;
 }
+interface BaseItemImage {
+    image_id: number;
+    base_item_id: number;
+    alias: string;
+    raw_path?: string | null;
+    processed_path?: string | null;
+    sort_index?: number;
+    local_key?: string | null;
+}
 interface MenuItem {
     base_item_id: number;
     category_id: number;
     franchise_id: number;
     name: string;
     per_person?: boolean | null;
-    image_path?: string | null;
+    images?: BaseItemImage[];
     variants: ItemVariant[];
     rules: Rule[];
     description?: string | null;
+    sort_index?: number | null;
     active_promo_id?: number;
     is_catering?: boolean;
 }
@@ -100,6 +187,8 @@ interface Rule {
     min_selection: number;
     max_selection?: number;
     included_quantity: number;
+    is_portionable?: boolean;
+    sort_index?: number | null;
     items?: RuleItem[];
     components?: RuleComponent[];
 }
@@ -110,6 +199,7 @@ interface RuleItem {
     upcharge_price: number;
     description?: string | null;
     behavior?: ScalingBehavior;
+    sort_index?: number | null;
 }
 interface RuleComponent {
     component_id: number;
@@ -119,6 +209,7 @@ interface RuleComponent {
     description?: string | null;
     behavior?: ScalingBehavior;
     serving_weight?: number;
+    sort_index?: number | null;
 }
 interface CustomizationOption {
     key: string;
@@ -130,14 +221,25 @@ interface CustomizationOption {
     selected: boolean;
     disabled: boolean;
     toggle: () => void;
+    /** Section this option currently targets; null when editing the whole item. */
+    portion?: string | null;
+    /** Section indices this option already covers, for shading the picker. */
+    coveredSections?: number[];
+    /** Already applied to the whole item, so individual sections are moot. */
+    coveredWhole?: boolean;
 }
 interface CustomizationRule extends Rule {
     rule_id: number;
     max: number;
+    /** Weighted, not a row count: two halves of one topping count as 1. */
     selectedCount: number;
     satisfied: boolean;
+    /** "Choose 1. Select up to 5. 1 included" — the rule's limits in words. */
+    subtext: string;
     message: () => string | null;
     options: CustomizationOption[];
+    /** This rule can be applied per-section under the item's scheme. */
+    portionable?: boolean;
 }
 interface OrderItem {
     item_id: number;
@@ -155,6 +257,7 @@ interface OrderItem {
     components?: OrderComponent[];
     selections?: RuleSelection[];
     comments?: string;
+    portion_scheme?: PortionScheme | null;
     status?: "removed" | "modified";
     applied_promo_id?: number;
     discount_amount?: number;
@@ -163,6 +266,7 @@ interface OrderComponent extends Component {
     quantity_servings: number;
     upcharge?: number;
     rule_id?: number;
+    portion?: string | null;
 }
 interface RuleSelection {
     rule_id: number;
@@ -177,10 +281,13 @@ interface Selection {
     serving_price?: number;
     name: string;
     status?: "removed" | "modified" | "added";
+    portion?: string | null;
     component_type_id?: number;
     serving_weight?: number;
     measurement_type?: "weight" | "count";
     display_unit?: string;
+    /** Only populated when type === "item" and the item has its own recipe (item_components). */
+    components?: OrderComponent[];
 }
 interface Customer {
     customer_id?: number;
@@ -229,6 +336,10 @@ interface Order {
     updated_at?: Date | string;
     table_number?: number;
 }
+type DetailedOrder = Order & {
+    events: EventRow[];
+    actorNames?: Record<string, string>;
+};
 interface Charge {
     id?: number;
     order_id?: number;
@@ -301,6 +412,56 @@ interface RecommendationResult {
     molecular_score?: number;
 }
 
+declare const franchiseFeatureConfigs: {
+    readonly catering: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+        notification_emails: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            email: z.ZodEmail;
+            location_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strip>>>>;
+        minimum_notice_hours: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minimum_people_required: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        minimum_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        does_cater: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        preferred_time: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    readonly delivery: z.ZodObject<{
+        does_deliver: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        delivery_fee_cents: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        max_delivery_radius_miles: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cents_per_mile: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly contact: z.ZodObject<{
+        forms: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+            label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>;
+    readonly catering_bulk_discount: z.ZodObject<{
+        is_active: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        full_discount_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maximum_percent_off: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly food_truck: z.ZodObject<{
+        base_price_per_person_cents: z.ZodNumber;
+        default_service_hours: z.ZodNumber;
+        additional_hour_rate_cents: z.ZodNumber;
+        service_fee_percent: z.ZodNumber;
+        sales_tax_percent: z.ZodNumber;
+        minimum_booking_fee_cents: z.ZodNumber;
+        date_hold_deposit_cents: z.ZodNumber;
+        add_ons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            price_per_person_cents: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+};
+type FranchiseFeatureId = keyof typeof franchiseFeatureConfigs;
+type FranchiseFeatureConfig<T extends FranchiseFeatureId> = z.infer<(typeof franchiseFeatureConfigs)[T]>;
+
 interface Menu {
     items: MenuItem[];
     categories: Category[];
@@ -308,6 +469,9 @@ interface Menu {
     rules: Rule[];
 }
 
+declare const CAPABILITIES: readonly ["ztech.page.franchises", "ztech.page.locations", "ztech.page.performance", "ztech.page.orders", "ztech.page.configure-location", "ztech.page.franchise-details", "ztech.page.integrations", "ztech.page.menu", "ztech.page.components", "ztech.page.catering", "ztech.page.promotions", "ztech.page.skills", "ztech.page.receipts", "ztech.page.users", "ztech.page.ingredient-inventory", "ztech.page.batch-prep", "ztech.page.devices", "ztech.page.tables", "portal.page.sales", "portal.page.analytics", "portal.page.analytics.overview", "portal.page.analytics.devices", "portal.page.analytics.backend", "portal.page.analytics.website", "portal.page.settings", "orders.view", "orders.refund", "orders.modify", "catering.view", "catering.confirm", "menu.edit", "promotions.edit", "staff.manage", "notifications.manage_self", "notifications.receive"];
+type Capability = (typeof CAPABILITIES)[number];
+
 interface ModalInstance {
     type: string;
     props: any;
@@ -363,6 +527,8 @@ declare function useCart(): {
 };
 declare function useLocation(options?: {
     promptLocationSelection?: boolean;
+    /** Location id to select for the user when nothing is selected yet. */
+    autoSelectLocationId?: number;
 }): {
     availableLocations: Location[];
     currentLocation: Location | null;
@@ -373,8 +539,12 @@ declare function useLocation(options?: {
 /**
  * Reactive menu data for the configured franchise.
  *
- * `items` excludes catering categories; use `allItems`,
- * `cateringPrimaryItem`, or `cateringAddOns` when building catering flows.
+ * `items` excludes catering categories (Category.is_catering — the sole catering
+ * signal per ZOR-396); `allItems` includes them.
+ *
+ * There is no catering-specific accessor here. A website builds its catering flow
+ * from the prebuilt `lib/generated/menu.ts` and `lib/generated/featureConfig.ts`,
+ * which is build-time-constant data and doesn't belong behind a reactive hook.
  *
  * @example
  * const { items, categories } = useMenu();
@@ -383,7 +553,6 @@ declare function useMenu(): {
     items: MenuItem[];
     allItems: MenuItem[];
     categories: Category[];
-    getItemImageUrl: (imagePath?: string | null) => string | null;
 };
 /**
  * Seeds a store with prebuilt data (see the app's prebuild script) during the
@@ -432,11 +601,27 @@ declare function useItemCustomization(baseItemId: number, seed?: OrderItem, edit
     unmetRule: CustomizationRule | null;
     canSubmit: boolean;
     submit: () => OrderItem | null;
+    portionScheme: {
+        id: number;
+        franchise_id: number;
+        geometry: "radial" | "grid" | "linear" | "count";
+        name: string;
+        min_divisions: number;
+        max_divisions: number;
+    } | null;
+    placeOption: (ruleId: number, baseKey: string, portion: string | null, max?: number) => void;
+    clearOption: (ruleId: number, baseKey: string) => void;
+    recutSelections: (next: number) => void;
     quantity: number;
-    setQuantity: React.Dispatch<React.SetStateAction<number>>;
+    setQuantity: (next: number | ((current: number) => number)) => void;
     comments: string;
-    setComments: React.Dispatch<React.SetStateAction<string>>;
-    setComponentServings: (componentId: number, qty: number) => void;
+    setComments: React$1.Dispatch<React$1.SetStateAction<string>>;
+    /**
+     * Set a component's servings for the whole item, or for one section when
+     * `portion` is given. 0 removes it — "no cheese", or "no cheese on the
+     * left half".
+     */
+    setComponentServings: (componentId: number, qty: number, portion?: string | null) => void;
     price: number;
     salePrice: number | undefined;
     isEditMode: boolean;
@@ -453,12 +638,15 @@ declare function usePromotions(): {
     removePromo: () => void;
     activePromotions: Promotion[];
 };
-declare function usePayment(): {
+declare function usePayment(options?: {
+    appearance?: StripeElementsOptions["appearance"];
+}): {
     clientSecret: string | null;
     intentType: "payment_intent" | "setup_intent" | null;
     stripe: _stripe_stripe_js.Stripe | undefined;
     elementOptions: StripeElementsOptions | null;
     total: number | null;
+    orderId: number | null;
     isLoading: boolean;
     error: string | null;
     isReady: boolean;
@@ -485,7 +673,11 @@ declare function usePayment(): {
         amount?: number;
         paymentIntentId?: string;
         error?: string;
+        isHold: boolean;
+        orderId?: number;
+        orderToken?: string;
     };
+    mintOrderLinkToken: (orderId: number, email: string) => Promise<string | null>;
     getReturnUrl: () => string | undefined;
 };
 declare function useCateringConfig(): {
@@ -613,6 +805,8 @@ declare const TextFieldSchema: z.ZodObject<{
     sanitize: z.ZodAny;
     min: z.ZodOptional<z.ZodString>;
     max: z.ZodOptional<z.ZodString>;
+    multiline: z.ZodDefault<z.ZodBoolean>;
+    rows: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 type TextFieldInput = Partial<z.infer<typeof TextFieldSchema>> & {
     fieldId: string;
@@ -658,9 +852,9 @@ declare const ClickableSchema: z.ZodObject<{
     optionSublabelClassName: z.ZodDefault<z.ZodString>;
     inputClassName: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
-type ClickableInput = Partial<z.infer<typeof ClickableSchema>> & {
+type ClickableInput = Omit<Partial<z.infer<typeof ClickableSchema>>, "options"> & {
     fieldId: string;
-    options: z.infer<typeof ClickableSchema>["options"];
+    options: z.input<typeof ClickableSchema>["options"];
 };
 
 declare function TextField(raw: TextFieldInput): react_jsx_runtime.JSX.Element;
@@ -741,6 +935,8 @@ declare const LocationFieldSchema: z.ZodObject<{
     sanitize: z.ZodAny;
     min: z.ZodOptional<z.ZodString>;
     max: z.ZodOptional<z.ZodString>;
+    multiline: z.ZodDefault<z.ZodBoolean>;
+    rows: z.ZodDefault<z.ZodNumber>;
     fieldId: z.ZodDefault<z.ZodString>;
     label: z.ZodDefault<z.ZodString>;
     placeholder: z.ZodDefault<z.ZodString>;
@@ -936,6 +1132,8 @@ declare const NameFieldsSchema: z.ZodObject<{
     sanitize: z.ZodAny;
     min: z.ZodOptional<z.ZodString>;
     max: z.ZodOptional<z.ZodString>;
+    multiline: z.ZodDefault<z.ZodBoolean>;
+    rows: z.ZodDefault<z.ZodNumber>;
     fieldId: z.ZodDefault<z.ZodString>;
     outerClassName: z.ZodDefault<z.ZodString>;
     firstNamePlaceholder: z.ZodDefault<z.ZodString>;
@@ -1105,4 +1303,281 @@ declare function useFormValues(): Record<string, unknown>;
 
 declare function useFormValidity(): boolean;
 
-export { type Category, CheckboxField, ClickableField, ConditionalRenderer, type Customer, type CustomizationOption, type CustomizationRule, DateField, DateTime, DateTimeRange, DisclaimerText, DiscreteNumberField, DynamicFormShell, EmailField, FieldError, FieldLabel, GuestCountField, Header, IncrementField, type ItemVariant, type Location, LocationField, type Menu, type MenuItem, NameFields, type Order, type OrderComponent, type OrderItem, PhoneField, Platforms, PerPersonSummary as PricePreview, type Promotion, type RecommendationRequest, type RecommendationResult, type RecommendationStrategy, type Rule, type RuleComponent, type RuleItem, type RuleSelection, SectionLabel, type Selection, SliderField, SubmitButton, TextField, type TimeConstraints, TimeField, setZorgoBoot, setZorgoPathnameHook, useCart, useCateringConfig, useCustomer, useField, useFormStatus, useFormValidity, useFormValues, useHydrateMenu, useHydrateStore, useItemCustomization, useLocation, useMenu, useModal, usePayment, usePromotions, useRecommendations, useRegisterField };
+type IconComponent = React.FC<SVGProps<SVGSVGElement>>;
+type StatusColor = "blue" | "green" | "red" | "gray";
+declare function resolveEventDisplay(eventName: string): {
+    label: string;
+    color: StatusColor;
+    icon?: IconComponent;
+};
+interface OrderApproval {
+    status: "requested" | "confirmed" | "rejected";
+    via: "pos" | "email_link" | "dashboard" | null;
+    when: string;
+    actorName: string | null;
+}
+/** null means no approval event exists yet — nearly every order today, since the
+ *  email-link path never recorded a userId before this ticket. Render that honestly
+ *  rather than a blank timeline. */
+declare function deriveApproval(order: DetailedOrder): OrderApproval | null;
+interface OrderStatusInfo {
+    label: string;
+    color: StatusColor;
+}
+declare function deriveOrderStatus(order: DetailedOrder): OrderStatusInfo;
+/** Mirrors confirmOrder's own promotable-status check — the button only appears when
+ *  clicking it wouldn't just no-op. */
+declare function isConfirmable(order: DetailedOrder): boolean;
+interface StatusColorClasses {
+    /** Field behind the status pill or a timeline icon. */
+    bg: string;
+    /** Ink on that field, and on the event's own label. */
+    text: string;
+    /** The bare dot drawn for an event that has no icon of its own. */
+    dot: string;
+}
+interface OrderStatusClasses {
+    root: string;
+    statusPill: string;
+    approval: string;
+    approvalEmpty: string;
+    timeline: string;
+    eventIcon: string;
+    eventLabel: string;
+    eventTime: string;
+    connectorLine: string;
+    connectorDelta: string;
+    confirmButton: string;
+    confirmError: string;
+    colors: Record<StatusColor, StatusColorClasses>;
+}
+type OrderStatusItemClasses = Partial<Omit<OrderStatusClasses, "colors"> & {
+    colors: Partial<Record<StatusColor, Partial<StatusColorClasses>>>;
+}>;
+/** ztech's dark chrome — what this component rendered before it took classes at all,
+ *  so a caller that passes none is unchanged. */
+declare const ORDER_STATUS_DEFAULT_ITEM_CLASSES: OrderStatusClasses;
+/**
+ * A slot **replaces** its default rather than appending to it: a site theming this is
+ * swapping `text-white` for its own ink, and two conflicting Tailwind classes in one
+ * string resolve by stylesheet order, not by who wrote them last.
+ *
+ * A restaurant site should expect to pass most of them. It reaches this component
+ * through @zorgo/next's index bundle, which its Tailwind never scans (only
+ * dist/components.mjs is @source'd), so a class named *only* in the defaults above
+ * never reaches that site's CSS.
+ */
+declare function mergeOrderStatusItemClasses(overrides?: OrderStatusItemClasses): OrderStatusClasses;
+interface OrderStatusProps {
+    order: DetailedOrder;
+    /** A predicate over whichever capabilities the caller already resolved — ztech passes
+     *  `useAccess().can`, a token-gated page passes one built from the server's resolved list.
+     *  This component never fetches and holds no session of its own. */
+    can: (capability: Capability) => boolean;
+    onConfirm?: () => void | Promise<void>;
+    confirming?: boolean;
+    confirmError?: string | null;
+    /** Per-slot Tailwind classes. Omitted slots keep the dark defaults above. */
+    itemClasses?: OrderStatusItemClasses;
+}
+declare function OrderStatus({ order, can, onConfirm, confirming, confirmError, itemClasses }: OrderStatusProps): react_jsx_runtime.JSX.Element;
+
+interface ItemizedAddOn {
+    name: string;
+    /** The rule/group this selection came from, e.g. "Proteins". */
+    groupName?: string;
+    /** Per-unit upcharge in cents. 0 means included at no extra cost. */
+    upcharge: number;
+}
+interface ItemizedLine {
+    name: string;
+    quantity: number;
+    /** One unit priced the way the line is: base + selection upcharges. */
+    unitPrice: number;
+    /** unitPrice * quantity — equals calculateItemPrice(item). */
+    lineTotal: number;
+    /** true = catering per-guest line, false = catering add-on, null/undefined = plain item. */
+    perPerson?: boolean | null;
+    addOns: ItemizedAddOn[];
+}
+interface ItemizedOrder {
+    lines: ItemizedLine[];
+    subtotal: number;
+    discount: number;
+    tax: number;
+    serviceFee: number;
+    tip: number;
+    /** What they were charged: charges.total + tip. */
+    total: number;
+}
+/**
+ * The receipt: every line with its add-ons, plus the charge breakdown.
+ *
+ * Catering and standard carts are the same shape — a list of items carrying
+ * selections — so there is one loop, and `perPerson` only labels a line for the
+ * UI rather than pricing it differently.
+ *
+ * Totals prefer the order's own settled charges — what was actually billed —
+ * over `calculateCharges`, which reprices against the current menu. A placed
+ * order's money is what Stripe took, not what today's menu would charge; an
+ * un-charged cart (still in checkout) has nothing settled, so it still prices
+ * itself live. Tip is passed in because it lives on the cart, not the order.
+ */
+declare function itemizeOrder(order: Order, promotion?: Promotion, tip?: number): ItemizedOrder;
+
+interface OrderItemizedClasses {
+    root: string;
+    line: string;
+    lineName: string;
+    lineSublabel: string;
+    linePrice: string;
+    addOn: string;
+    addOnName: string;
+    addOnPrice: string;
+    totalsRow: string;
+    discountRow: string;
+    totalRow: string;
+}
+type OrderItemizedItemClasses = Partial<OrderItemizedClasses>;
+/** ztech's dark chrome, matching OrderStatus's defaults — a caller that passes none is unchanged. */
+declare const ORDER_ITEMIZED_DEFAULT_ITEM_CLASSES: OrderItemizedClasses;
+/**
+ * A slot **replaces** its default rather than appending to it — see OrderStatus's
+ * mergeOrderStatusItemClasses for why (a restaurant site's Tailwind only scans
+ * dist/components.mjs, so a class named only in the defaults never reaches it).
+ */
+declare function mergeOrderItemizedItemClasses(overrides?: OrderItemizedItemClasses): OrderItemizedClasses;
+declare function formatCateringLineLabel(line: ItemizedLine): string;
+declare function formatAddOnPrice(addOn: ItemizedAddOn, perPerson?: boolean | null): string;
+interface OrderItemizedProps {
+    order: Order;
+    promotion?: Promotion;
+    tip?: number;
+    /** Per-slot Tailwind classes. Omitted slots keep the dark defaults above. */
+    itemClasses?: OrderItemizedItemClasses;
+}
+/** The receipt: every line with its add-ons, plus the charge breakdown. Pure render from
+ *  itemizeOrder(order) — never fetches, same contract as OrderStatus. */
+declare function OrderItemized({ order, promotion, tip, itemClasses }: OrderItemizedProps): react_jsx_runtime.JSX.Element;
+
+declare function parsePortion(portion: string): {
+    index: number;
+    divisions: number;
+};
+/** A section's share of the whole. No portion = the whole item = 1. */
+declare function portionWeight(portion?: string | null): number;
+/**
+ * Selection keys carry their portion as a suffix: `component:123@1/2`. A bare
+ * key is the whole item, which is what every pre-portion key already is — so
+ * existing state parses unchanged.
+ */
+declare function portionKey(baseKey: string, portion?: string | null): string;
+declare function parsePortionKey(key: string): {
+    baseKey: string;
+    portion: string | null;
+};
+/**
+ * A section's share of a whole-item upcharge, in cents. Rounds up, so covering
+ * every section can cost a cent or two more than the whole — which is why a
+ * selection covering everything collapses to a single portion-less row instead.
+ */
+declare function splitUpcharge(cents: number, divisions: number): number;
+/** Every division count a scheme allows, for the picker's cut selector. */
+declare function divisionsFor(scheme: Pick<PortionScheme, "min_divisions" | "max_divisions">): number[];
+/**
+ * The one place a section index becomes words. The picker, the cart line, the
+ * receipt and the KDS ticket all call this on the same scheme, so the index is
+ * the only token the UI and the data share.
+ */
+declare function portionLabel(portion: string | null | undefined, scheme: Pick<PortionScheme, "geometry">): string;
+/**
+ * Expand per-section overrides on one keyed entity into one row per section —
+ * how "no cheese on the left half" becomes a 0-serving row for that section and
+ * a normal row for the rest. No overrides, or the same value on every section,
+ * is a single whole-item row (§3 collapse).
+ */
+declare function portionRows(baseKey: string, values: Record<string, number>, fallback: number): {
+    portion: string | null;
+    value: number;
+}[];
+/** Weighted count of a rule's selections: two halves of one topping count as 1. */
+declare function selectionWeight(keys: string[]): number;
+/**
+ * Spend `included_quantity` on selection keys in pick order. A topping is a
+ * topping: it takes one included slot no matter how little of the pizza it covers,
+ * so putting pepperoni on one half never leaves half a free slot behind to
+ * discount everything else — and its rows share that one slot, so two halves of
+ * pepperoni consume one included topping, not two. With no portions this is
+ * exactly the old positional rule (`position < included ? 0 : basePrice`).
+ */
+declare function weightedUpcharges(keys: string[], basePriceOf: (baseKey: string) => number, included: number): Map<string, number>;
+/**
+ * Re-express a portion under a different cut, for when the customer switches
+ * from halves to quarters mid-order. Returns null when neither count divides the
+ * other (halves → thirds), meaning the selection can't be carried over.
+ */
+declare function remapPortion(portion: string, nextDivisions: number): string[] | null;
+/**
+ * Positional section wording, geometry-free — deliberately not `portionLabel`.
+ * Derived words ("Left", "Top left") only exist for a few geometry/division
+ * pairs and need the scheme; a receipt has to say something for every cut.
+ */
+declare function sectionLabel(portion?: string | null): string;
+/** A text glyph for a section, or null when unicode has no character for it. */
+declare function portionGlyph(portion: string | null | undefined, geometry?: PortionGeometry | null): string | null;
+interface PortionGroup {
+    portion: string | null;
+    label: string;
+    glyph: string | null;
+    /** The item's rules, each carrying only the selections that land on this section. */
+    selections: RuleSelection[];
+    removals: OrderComponent[];
+    /**
+     * Components present on this section. Whole-item components are the base
+     * recipe — implied by the item's name — so only portioned ones land here,
+     * where "pepperoni on the left" is the whole point of the line.
+     */
+    additions: OrderComponent[];
+}
+/**
+ * One group per covered section: the whole-item group first, then sections in
+ * index order, rules keeping their original order inside each. An item with no
+ * portions anywhere yields exactly one whole-item group, so a surface can render
+ * this unconditionally and show the heading only when `portion_scheme` is set.
+ *
+ * It groups and nothing else — every selection it is handed comes back out. What
+ * counts as worth printing is the surface's call, not this function's.
+ */
+declare function groupItemPortions(item: Pick<OrderItem, "selections" | "components" | "portion_scheme">): PortionGroup[];
+declare function radialSectionPath(index: number, divisions: number, r?: number): string;
+
+/** Same opinionated TZ as legacy menu checks. */
+declare const LOCATION_ORDERING_TIMEZONE = "America/New_York";
+declare const DAYS: readonly ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+/** The open/close instants of one calendar day's window, in LOCATION_ORDERING_TIMEZONE. */
+interface LocationWindow {
+    /** Lowercase weekday the window's hours were read from. */
+    day: (typeof DAYS)[number];
+    open: Date;
+    close: Date;
+}
+/**
+ * The open/close instants for the day `dayOffset` days from `at`, read in
+ * LOCATION_ORDERING_TIMEZONE. Null when that weekday has no hours set.
+ *
+ * A close at or before the open is read as closing after midnight, so an
+ * 11pm–2am window is one continuous night rather than a closed day.
+ */
+declare function locationWindowOn(at: Date, location: Location, dayOffset?: number): LocationWindow | null;
+/**
+ * True when the location is outside its weekly open window at `at`
+ * (includes `force_close`). Yesterday's window is checked too, so the small
+ * hours of an overnight window still count as open.
+ */
+declare function isLocationClosedByWeeklySchedule(at: Date, location: Location): boolean;
+
+type CateringSiteConfig = Omit<FranchiseFeatureConfig<"catering">, "notification_emails">;
+type CateringBulkDiscount = FranchiseFeatureConfig<"catering_bulk_discount">;
+type FoodTruckConfigValue = FranchiseFeatureConfig<"food_truck">;
+
+export { type Capability, type Category, type CateringBulkDiscount, type CateringSiteConfig, CheckboxField, ClickableField, ConditionalRenderer, type Customer, type CustomizationOption, type CustomizationRule, DateField, DateTime, DateTimeRange, type DetailedOrder, DisclaimerText, DiscreteNumberField, DynamicFormShell, EmailField, type EventRow, FieldError, FieldLabel, type FoodTruckConfigValue, type FranchiseFeatureConfig, GuestCountField, Header, IncrementField, type ItemVariant, type ItemizedAddOn, type ItemizedLine, type ItemizedOrder, LOCATION_ORDERING_TIMEZONE, type Location, LocationField, type LocationWindow, type Menu, type MenuItem, NameFields, ORDER_ITEMIZED_DEFAULT_ITEM_CLASSES, ORDER_STATUS_DEFAULT_ITEM_CLASSES, type Order, type OrderApproval, type OrderComponent, type OrderItem, OrderItemized, type OrderItemizedClasses, type OrderItemizedItemClasses, type OrderItemizedProps, OrderStatus, type OrderStatusClasses, type OrderStatusInfo, type OrderStatusItemClasses, type OrderStatusProps, PhoneField, Platforms, type PortionGroup, PerPersonSummary as PricePreview, type Promotion, type RecommendationRequest, type RecommendationResult, type RecommendationStrategy, type Rule, type RuleComponent, type RuleItem, type RuleSelection, SectionLabel, type Selection, SliderField, type StatusColorClasses, SubmitButton, TextField, type TimeConstraints, TimeField, deriveApproval, deriveOrderStatus, divisionsFor, formatAddOnPrice, formatCateringLineLabel, groupItemPortions, isConfirmable, isLocationClosedByWeeklySchedule, itemizeOrder, locationWindowOn, mergeOrderItemizedItemClasses, mergeOrderStatusItemClasses, parsePortion, parsePortionKey, portionGlyph, portionKey, portionLabel, portionRows, portionWeight, radialSectionPath, remapPortion, resolveEventDisplay, sectionLabel, selectionWeight, setZorgoBoot, setZorgoPathnameHook, splitUpcharge, useCart, useCateringConfig, useCustomer, useField, useFormStatus, useFormValidity, useFormValues, useHydrateMenu, useHydrateStore, useItemCustomization, useLocation, useMenu, useModal, usePayment, usePromotions, useRecommendations, useRegisterField, weightedUpcharges };