@zorgo/next 1.3.0 → 2.0.0

package/dist/components.d.mts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { z } from 'zod';
-import { ReactNode } from 'react';
+import { ReactNode, AnchorHTMLAttributes, ButtonHTMLAttributes } from 'react';
 
 declare function CookieConsent(): react_jsx_runtime.JSX.Element | null;
 
@@ -26,6 +26,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;
@@ -52,6 +54,7 @@ interface Category {
     name: string;
     is_catering?: boolean;
     rules: Rule[];
+    sort_index?: number | null;
     active_promo_id?: number;
 }
 interface ItemVariant {
@@ -63,6 +66,7 @@ interface ItemVariant {
     rules?: Rule[];
     portion_scheme_id?: number | null;
     portion_scheme?: PortionScheme | null;
+    sort_index?: number | null;
     display_price?: number;
     active_promo_id?: number;
 }
@@ -85,6 +89,7 @@ interface MenuItem {
     variants: ItemVariant[];
     rules: Rule[];
     description?: string | null;
+    sort_index?: number | null;
     active_promo_id?: number;
     is_catering?: boolean;
 }
@@ -120,6 +125,7 @@ interface Rule {
     max_selection?: number;
     included_quantity: number;
     is_portionable?: boolean;
+    sort_index?: number | null;
     items?: RuleItem[];
     components?: RuleComponent[];
 }
@@ -130,6 +136,7 @@ interface RuleItem {
     upcharge_price: number;
     description?: string | null;
     behavior?: ScalingBehavior;
+    sort_index?: number | null;
 }
 interface RuleComponent {
     component_id: number;
@@ -139,6 +146,7 @@ interface RuleComponent {
     description?: string | null;
     behavior?: ScalingBehavior;
     serving_weight?: number;
+    sort_index?: number | null;
 }
 interface CustomizationOption {
     key: string;
@@ -215,8 +223,70 @@ interface Selection {
     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 Menu {
+    items: MenuItem[];
+    categories: Category[];
+    components: Component[];
+    rules: Rule[];
+}
+
+/** Per-slot Tailwind classes for a single item card. */
+type ItemCardItemClasses = Partial<{
+    card: string;
+    imageBox: string;
+    image: string;
+    placeholder: string;
+    textContainer: string;
+    name: string;
+    price: string;
+    oldPrice: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeItemCardItemClasses}.
+ */
+declare const ITEM_CARD_DEFAULT_ITEM_CLASSES: Required<ItemCardItemClasses>;
+declare function mergeItemCardItemClasses(overrides?: ItemCardItemClasses): {
+    card: string;
+    imageBox: string;
+    image: string;
+    placeholder: string;
+    textContainer: string;
+    name: string;
+    price: string;
+    oldPrice: string;
+};
+type ItemCardProps = {
+    itemClasses?: ItemCardItemClasses;
+    /** Widest slot the card occupies, per breakpoint. */
+    sizes?: string;
+    priority?: boolean;
+    /** Overrides the `/menu/[slug]` target — see {@link CategoryTiles}. */
+    href?: string;
+    /** Overrides the displayed name and the no-image tile's text. */
+    label?: string;
+    /** Emit this dish's MenuItem JSON-LD beside the card. Off by default: the
+     *  site-wide Restaurant node already carries every item under `hasMenu`. */
+    jsonLd?: boolean;
+} & ({
+    item: MenuItem;
+} | {
+    menu: Menu;
+    bid: number;
+});
+/**
+ * One clickable dish: photo (or a typographic tile when there is none), name,
+ * price — linking to that item's page. Pass `item` directly, or `menu` + `bid`
+ * to pick a base item out of the prebuilt menu.
+ *
+ * Renders nothing for a bid the menu does not contain.
+ */
+declare function ItemCard({ itemClasses, sizes, priority, href, label, jsonLd, ...source }: ItemCardProps): react_jsx_runtime.JSX.Element | null;
+
 /** Per-slot Tailwind classes for the grid menu layout. */
 type GridMenuItemClasses = Partial<{
     baseContainer: string;
@@ -262,6 +332,9 @@ type AccordionMenuItemClasses = Partial<{
     categoryIndicator: string;
     itemsContainer: string;
     itemCard: string;
+    itemCardFeatured: string;
+    itemCardImageBox: string;
+    itemCardImage: string;
     itemCardTextContainer: string;
     itemCardName: string;
     itemCardDescription: string;
@@ -282,6 +355,9 @@ declare function mergeAccordionMenuItemClasses(overrides?: AccordionMenuItemClas
     categoryIndicator: string;
     itemsContainer: string;
     itemCard: string;
+    itemCardFeatured: string;
+    itemCardImageBox: string;
+    itemCardImage: string;
     itemCardTextContainer: string;
     itemCardName: string;
     itemCardDescription: string;
@@ -289,10 +365,16 @@ declare function mergeAccordionMenuItemClasses(overrides?: AccordionMenuItemClas
     itemCardPrice: string;
     itemCardOldPrice: string;
 };
-declare function AccordionMenu({ items, categories, itemClasses, }: {
+declare function AccordionMenu({ items, categories, itemClasses, 
+/** MN-07: small square thumb left of the name/description. Off by default so a menu with no item images (nothing in base_item_images yet) doesn't render a grid of empty placeholders. */
+showImages, 
+/** MN-03: base_item_ids to render with the reserved featured (red panel) variant instead of the default card. */
+featuredBaseItemIds, }: {
     items: MenuItem[];
     categories: Category[];
     itemClasses?: AccordionMenuItemClasses;
+    showImages?: boolean;
+    featuredBaseItemIds?: number[];
 }): react_jsx_runtime.JSX.Element;
 
 declare function money(cents: number): string;
@@ -512,6 +594,173 @@ interface PortionPickerProps extends PortionShapeProps {
  */
 declare function PortionPicker({ scheme, divisions, active, covered, onSelect, onDivisionsChange, className, }: PortionPickerProps): react_jsx_runtime.JSX.Element;
 
+/** Per-slot Tailwind classes for the status pill. */
+type OpenStatusItemClasses = Partial<{
+    root: string;
+    dot: string;
+    dotOpen: string;
+    dotClosed: string;
+    label: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeOpenStatusItemClasses}.
+ */
+declare const OPEN_STATUS_DEFAULT_ITEM_CLASSES: Required<OpenStatusItemClasses>;
+declare function mergeOpenStatusItemClasses(overrides?: OpenStatusItemClasses): {
+    root: string;
+    dot: string;
+    dotOpen: string;
+    dotClosed: string;
+    label: string;
+};
+/**
+ * Whether `location` is serving at `now`, and the sentence that says so —
+ * "Open until 11pm" / "Closed · opens 11am Tuesday". Pure: every branch is
+ * decided by the location's fourteen day-fields and the instant passed in.
+ */
+declare function openStatus(location: Location, now: Date): {
+    open: boolean;
+    label: string;
+};
+type OpenStatusProps = {
+    location: Location | null | undefined;
+    /**
+     * Pin the instant to judge against. Left unset the component reads the
+     * visitor's clock after mount and re-checks every minute, so a page built
+     * hours ago never claims to be open once the kitchen has closed.
+     */
+    now?: Date;
+    itemClasses?: OpenStatusItemClasses;
+};
+/**
+ * Open/closed pill for one location.
+ *
+ * Renders nothing until the visitor's clock is known — the server and the first
+ * client render must agree, and a statically built page has no instant that is
+ * still true when it is served. The hours themselves reach crawlers through the
+ * page's JSON-LD, not through this pill.
+ */
+declare function OpenStatus({ location, now, itemClasses }: OpenStatusProps): react_jsx_runtime.JSX.Element | null;
+
+/** Franchise-level facts for the Restaurant node. Everything but `name` is
+ *  optional so the schema degrades gracefully when a field is missing. */
+interface RestaurantInfo {
+    name: string;
+    url?: string;
+    image?: string;
+    description?: string;
+    servesCuisine?: string[];
+    /** Public locations from `lib/generated/locations.ts`. One location's facts
+     *  land on the Restaurant node itself; several become linked branches. */
+    locations?: Location[];
+}
+
+/** Per-slot Tailwind classes for a location card and the section that lists them. */
+type LocationCardItemClasses = Partial<{
+    section: string;
+    title: string;
+    grid: string;
+    card: string;
+    cardWide: string;
+    body: string;
+    header: string;
+    name: string;
+    status: string;
+    rows: string;
+    row: string;
+    rowIcon: string;
+    rowText: string;
+    map: string;
+    mapFrame: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeLocationCardItemClasses}.
+ */
+declare const LOCATION_CARD_DEFAULT_ITEM_CLASSES: Required<LocationCardItemClasses>;
+declare function mergeLocationCardItemClasses(overrides?: LocationCardItemClasses): {
+    section: string;
+    title: string;
+    grid: string;
+    card: string;
+    cardWide: string;
+    body: string;
+    header: string;
+    name: string;
+    status: string;
+    rows: string;
+    row: string;
+    rowIcon: string;
+    rowText: string;
+    map: string;
+    mapFrame: string;
+};
+/**
+ * The map pane's `src` and the address row's `href`, which are not the same URL
+ * and cannot be derived from each other:
+ *
+ * - A site-supplied `mapUrl` is normally a share link to the real Place listing
+ *   — reviews, photos, the pin on the right unit of a shared plaza. Google turns
+ *   any such link into an iframe with `output=embed`, and a `/maps/embed?pb=`
+ *   URL already is one. That form has no place page behind it, so it is a `src`
+ *   only and the row falls back to the coordinate search.
+ * - With no `mapUrl` the pane is derived from the address (or coordinates), which
+ *   is enough for "where is it" and needs no API key. `null` is the one way to
+ *   say "no map here" — `undefined` cannot be, since that is also what a caller
+ *   passing nothing sends.
+ */
+declare function locationMap(location: Location, mapUrl?: string | null): {
+    src?: string;
+    href?: string;
+};
+/** A card carrying a map takes the full container width; a plain one shares an auto-fit row. */
+declare function locationGridClass(wide: boolean): string;
+type LocationCardProps = {
+    location: Location | null | undefined;
+    /** That location's own page, when the site has one. */
+    href?: string;
+    /**
+     * This location on Google Maps — a share link to its Place listing, or an
+     * embed URL. Omitted, the card derives one from the address; `null` drops
+     * the map pane and keeps the narrow card.
+     */
+    mapUrl?: string | null;
+    /** Pins the open/closed clock — see {@link OpenStatus}. */
+    now?: Date;
+    /**
+     * Franchise facts. Supplied, the card also emits this location's branch
+     * JSON-LD — only worth doing on the page that *is* this location's, since
+     * the parent node already carries a lone location's facts.
+     */
+    info?: RestaurantInfo;
+    itemClasses?: LocationCardItemClasses;
+};
+/**
+ * One location: name and live open/closed up top, then a stack of tappable
+ * rows — address opens the map, phone dials, and the last row leads to that
+ * location's page — beside a map of where it actually is. Every field is
+ * optional in the data, so each row drops out on its own rather than leaving an
+ * empty line behind.
+ */
+declare function LocationCard({ location, href, mapUrl, now, info, itemClasses, }: LocationCardProps): react_jsx_runtime.JSX.Element | null;
+type LocationsSectionProps = Omit<LocationCardProps, "location" | "href" | "mapUrl"> & {
+    locations: Location[];
+    title?: string;
+    /** Builds each card's page link; omit when the site has no location pages. */
+    href?: (location: Location) => string;
+    /**
+     * Pins each card's Google Maps URL, either as a `location_id` → URL lookup —
+     * the usual shape, since the locations themselves come from the database and
+     * the Place links are hand-collected — or as a builder. A location the lookup
+     * has no entry for derives its map from its address, as it would with no
+     * `mapUrl` at all; `null` is how a site says "no map on this one".
+     */
+    mapUrl?: Record<number, string | null> | ((location: Location) => string | null | undefined);
+};
+/** The homepage/locations grid of {@link LocationCard}s. Nothing when empty. */
+declare function LocationsSection({ locations, title, href, mapUrl, itemClasses, ...card }: LocationsSectionProps): react_jsx_runtime.JSX.Element | null;
+
 /** Per-slot Tailwind classes for the find-location layout. */
 type FindLocationItemClasses = Partial<{
     baseContainer: string;
@@ -622,6 +871,28 @@ declare function mergeCheckoutFormItemClasses(overrides?: CheckoutFormItemClasse
  */
 type CheckoutFormSlots = Required<CheckoutFormItemClasses>;
 declare const CHECKOUT_FORM_SLOTS: CheckoutFormSlots;
+/**
+ * Copy for a card *hold* — a Stripe SetupIntent rather than a PaymentIntent.
+ * The server issues one when the order is catering (create-payment-intent.ts
+ * branches on order.is_catering): the card is saved and nothing is charged
+ * until a manager confirms. Without this, checkout told the customer they had
+ * paid when no money had moved.
+ *
+ * Defaulted and overridable: the wording is catering-shaped today, but holding
+ * a card is not a catering-only idea.
+ */
+interface CheckoutHoldCopy {
+    submitLabel: string;
+    submitLoadingLabel: string;
+    successTitle: string;
+    /**
+     * Called with the formatted amount, or `null` when it isn't known — the
+     * Stripe return URL only carries one if we put it there, and a hold panel
+     * that promises to charge "$0.00" is worse than one that names no figure.
+     */
+    successMessage: (amount: string | null) => string;
+}
+declare const CHECKOUT_HOLD_COPY: CheckoutHoldCopy;
 
 /**
  * The stock checkout flow: cart + customer details, then Stripe payment.
@@ -631,11 +902,24 @@ declare const CHECKOUT_FORM_SLOTS: CheckoutFormSlots;
  * The order + payment intent are created on details submit (not on mount),
  * so the collected customer and any applied promo are baked into the charge.
  */
-declare function CheckoutForm({ itemClasses, homeHref, menuHref, checkoutHref, }: {
+declare function CheckoutForm({ itemClasses, homeHref, menuHref, checkoutHref, holdCopy, successAction, }: {
     itemClasses?: CheckoutFormItemClasses;
     homeHref?: string;
     menuHref?: string;
     checkoutHref?: string;
+    holdCopy?: Partial<CheckoutHoldCopy>;
+    /**
+     * Replaces the "Back home" button on the success panel.
+     *
+     * Takes the order id and its read token when the return URL carried them —
+     * enough to link the customer straight to their own order. Both are absent
+     * whenever the mint before the redirect failed, so an implementation has to
+     * render something sensible without them.
+     */
+    successAction?: (context: {
+        orderId?: number;
+        orderToken?: string;
+    }) => ReactNode;
 }): react_jsx_runtime.JSX.Element;
 
 /** Page wrapper + title every checkout state renders inside. */
@@ -708,9 +992,455 @@ declare function DetailsStep({ slots, }: {
 }): react_jsx_runtime.JSX.Element;
 
 /** Step 2: the Stripe payment element. Must be rendered inside `<Elements>`. */
-declare function PaymentStep({ slots, checkoutHref, }: {
+declare function PaymentStep({ slots, checkoutHref, holdCopy, }: {
     slots?: CheckoutFormSlots;
     checkoutHref?: string;
+    holdCopy?: Partial<CheckoutHoldCopy>;
 }): react_jsx_runtime.JSX.Element;
 
-export { ACCORDION_MENU_DEFAULT_ITEM_CLASSES, AccordionMenu, type AccordionMenuItemClasses, BREADCRUMBS_DEFAULT_ITEM_CLASSES, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsItemClasses, CHECKOUT_FORM_DEFAULT_ITEM_CLASSES, CHECKOUT_FORM_SLOTS, CLIENT_ITEM_FORM_DEFAULT_ITEM_CLASSES, CLIENT_ITEM_FORM_SLOTS, CheckoutForm, type CheckoutFormItemClasses, type CheckoutFormSlots, CheckoutShell, CheckoutSteps, ClientItemForm, type ClientItemFormItemClasses, type ClientItemFormSlots, CommentsSection, ComponentsSection, ConsentFields, ContactFields, CookieConsent, DetailsStep, FIND_LOCATION_DEFAULT_ITEM_CLASSES, FindLocation, type FindLocationItemClasses, GRID_MENU_DEFAULT_ITEM_CLASSES, GridMenu, type GridMenuItemClasses, CLIENT_ITEM_FORM_DEFAULT_ITEM_CLASSES as ITEM_CUSTOMIZATION_FORM_DEFAULT_ITEM_CLASSES, ClientItemForm as ItemCustomizationClient, ClientItemForm as ItemCustomizationForm, type ClientItemFormItemClasses as ItemCustomizationFormItemClasses, OptionButton, OrderLine, OrderLines, OrderTotals, PaymentStep, PortionPicker, type PortionPickerProps, PortionSection, type PortionShapeProps, PromoCode, QuantitySection, RuleSection, StatusPanel, SubmitButton, VariantSection, mergeAccordionMenuItemClasses, mergeBreadcrumbsItemClasses, mergeCheckoutFormItemClasses, mergeClientItemFormItemClasses, mergeFindLocationItemClasses, mergeGridMenuItemClasses, mergeClientItemFormItemClasses as mergeItemCustomizationFormItemClasses, money };
+type ButtonVariant = "primary" | "secondary";
+/** "auto" caps the button at its label + padding (FT-02); "full" stretches, but only below the sm breakpoint — a button should never stretch to ~1200px for two words on desktop. */
+type ButtonWidth = "auto" | "full";
+/** Per-slot Tailwind classes for a button. */
+type ButtonItemClasses = Partial<{
+    base: string;
+    primary: string;
+    secondary: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeButtonItemClasses}.
+ *
+ * min-h-11 (44px) is Tailwind's stock h-11 step and also the standard
+ * touch-target floor (MB-02) — no separate constant needed for it.
+ *
+ * Brand-specific button geometry (Zestia's pill radius, uppercase Gotham Black,
+ * wider tracking) is a per-site decision, so it goes through `itemClasses` at
+ * the call site rather than into this default — every value the Zestia guide
+ * names has an exact stock Tailwind step (`rounded-full`, `font-black`,
+ * `tracking-wider`, `px-6`, `py-3`), so no arbitrary value is needed for it.
+ */
+declare const BUTTON_DEFAULT_ITEM_CLASSES: Required<ButtonItemClasses>;
+declare function mergeButtonItemClasses(overrides?: ButtonItemClasses): {
+    base: string;
+    primary: string;
+    secondary: string;
+};
+/** FT-02's width rule as a pure decision: only "full" may stretch, and only on mobile. */
+declare function buttonWidthClass(width: ButtonWidth): string;
+type SharedProps = {
+    variant?: ButtonVariant;
+    width?: ButtonWidth;
+    itemClasses?: ButtonItemClasses;
+    children: ReactNode;
+};
+type ButtonProps = SharedProps & (({
+    href: string;
+} & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "className">) | ({
+    href?: undefined;
+} & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "className">));
+/** One clickable action: a link when `href` is passed, a `<button>` otherwise. Same width/variant rules either way. */
+declare function Button({ variant, width, itemClasses, children, href, ...rest }: ButtonProps): react_jsx_runtime.JSX.Element;
+
+/** A button's own slots plus the bar it pins to on mobile. */
+type StickyButtonItemClasses = ButtonItemClasses & Partial<{
+    bar: string;
+}>;
+/**
+ * The bar is only a bar below `sm`: `sm:contents` drops the wrapper out of the
+ * layout entirely, so from that breakpoint up the button is an ordinary flex or
+ * inline child of whatever holds it — which is the whole point of the
+ * component, and why `Button`'s `full` width (`w-full sm:w-fit`) switches at the
+ * same step.
+ */
+declare const STICKY_BUTTON_DEFAULT_BAR_CLASS = "fixed inset-x-0 bottom-0 z-40 flex justify-center border-t border-foreground/10 bg-background p-4 sm:contents";
+/**
+ * Omitted `stickyOn` pins on every route; an empty list pins on none. Route
+ * matching is {@link isNavLinkActive}'s — "/" exact, everything else its own
+ * subtree — so the routes read the same here as they do in a nav.
+ */
+declare function isStickyRoute(pathname: string | null, stickyOn?: string[]): boolean;
+type StickyButtonProps = ButtonProps & {
+    /** Routes where this pins to the bottom of the viewport on mobile. */
+    stickyOn?: string[];
+    /**
+     * Reserves the bar's height in the flow. Wanted where the component sits at
+     * the end of a page (nothing should hide under the bar); not wanted in a
+     * header, where the bar's height is nowhere near the button's own place.
+     */
+    spacer?: boolean;
+    itemClasses?: StickyButtonItemClasses;
+};
+/**
+ * One CTA that is an ordinary {@link Button} on desktop and a pinned
+ * bottom-of-screen bar on mobile, per route. Width is owned here rather than
+ * taken as a prop: pinned is always full-width (FT-02's mobile-only exception),
+ * inline is always capped at its label.
+ */
+declare function StickyButton({ stickyOn, spacer, itemClasses, width: _width, ...rest }: StickyButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Class slots an accordion section needs. Each consumer maps its own slot
+ * names onto these — see {@link AccordionMenu} and {@link FaqAccordion}.
+ */
+type AccordionSectionSlots = Partial<{
+    container: string;
+    trigger: string;
+    indicator: string;
+    body: string;
+}>;
+/**
+ * One expandable section: a trigger with a chevron over a body. The body stays
+ * in the markup while collapsed — `hidden`, not unmounted — so its content is
+ * still there for crawlers.
+ *
+ * `title` is a node rather than a string so the caller supplies its own
+ * heading level.
+ */
+declare function AccordionSection({ title, slots, defaultOpen, id, children, }: {
+    title: ReactNode;
+    slots: AccordionSectionSlots;
+    defaultOpen?: boolean;
+    /** Anchor target, so a link can address this section. */
+    id?: string;
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/** One site-authored question and its answer. */
+type Faq = {
+    question: string;
+    answer: string;
+};
+/** Per-slot Tailwind classes for the FAQ accordion. */
+type FaqAccordionItemClasses = Partial<{
+    section: string;
+    title: string;
+    list: string;
+    item: string;
+    trigger: string;
+    question: string;
+    indicator: string;
+    answer: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeFaqAccordionItemClasses}.
+ */
+declare const FAQ_ACCORDION_DEFAULT_ITEM_CLASSES: Required<FaqAccordionItemClasses>;
+declare function mergeFaqAccordionItemClasses(overrides?: FaqAccordionItemClasses): {
+    section: string;
+    title: string;
+    list: string;
+    item: string;
+    trigger: string;
+    question: string;
+    indicator: string;
+    answer: string;
+};
+type FaqAccordionProps = {
+    faqs: Faq[];
+    title?: string;
+    /** Index of the one question open on arrival — none by default. */
+    defaultOpen?: number;
+    itemClasses?: FaqAccordionItemClasses;
+};
+/**
+ * Site-authored Q&A. Answers stay in the markup while collapsed, which is the
+ * whole point of the block — AI answer engines quote them. Deliberately emits
+ * no `FAQPage` JSON-LD: Google removed FAQ rich results from Search in May
+ * 2026, so the markup would buy nothing.
+ */
+declare function FaqAccordion({ faqs, title, defaultOpen, itemClasses, }: FaqAccordionProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * One site-authored photo, served from the site's own `public/`. These are not
+ * in the data pipeline — unlike item photos there is no prebuild step that
+ * localizes them.
+ */
+type GalleryImage = {
+    src: string;
+    alt: string;
+};
+/** Per-slot Tailwind classes for the photo gallery. */
+type GalleryItemClasses = Partial<{
+    section: string;
+    title: string;
+    list: string;
+    figure: string;
+    image: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeGalleryItemClasses}.
+ */
+declare const GALLERY_DEFAULT_ITEM_CLASSES: Required<GalleryItemClasses>;
+declare function mergeGalleryItemClasses(overrides?: GalleryItemClasses): {
+    section: string;
+    title: string;
+    list: string;
+    figure: string;
+    image: string;
+};
+type GalleryProps = {
+    images: GalleryImage[];
+    title?: string;
+    /** Widest slot one photo occupies, per breakpoint. */
+    sizes?: string;
+    itemClasses?: GalleryItemClasses;
+};
+/**
+ * Interior and food photos, authored by the site under `public/`. The row
+ * grows to fill whatever it is given, so two photos read as deliberate rather
+ * than as ten that failed to load.
+ */
+declare function Gallery({ images, title, sizes, itemClasses, }: GalleryProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * One first-party testimonial: something a customer said to the restaurant,
+ * published with their permission.
+ *
+ * First-party is the whole design. Reprinting reviews off Google or Yelp is two
+ * problems the component cannot solve for a site — the review text is the
+ * reviewer's own copyrighted writing, and the platforms' terms restrict
+ * republishing it — so there is no `source: "google"` field here to invite it.
+ * A site that wants platform reviews on the page embeds that platform's own
+ * widget, which carries its licence with it.
+ *
+ * `name` is required rather than optional on purpose. An unattributed quote is
+ * the exact shape of a testimonial nobody can check, and the FTC's Rule on the
+ * Use of Consumer Reviews and Testimonials (16 CFR 465, in force since October
+ * 21 2024) puts civil penalties behind fabricated ones. A first name and a city
+ * is plenty; what matters is that a real person said it and the restaurant can
+ * show they did.
+ */
+type Testimonial = {
+    /** Verbatim. Trim it and you are editing what someone said into something they did not. */
+    quote: string;
+    /** Attribution, as the customer agreed to it being published — "Marisa T." is fine. */
+    name: string;
+    /** Optional colour under the name: a city, "catering customer", "regular since 2019". */
+    detail?: string;
+    /** `YYYY-MM-DD`. Rendered as month + year, and machine-readable in `datetime`. */
+    date?: string;
+    /** 1–5. Omit it rather than inventing one. */
+    rating?: number;
+    /**
+     * Required by the FTC whenever the reviewer got anything of value for the
+     * review — a discount, a free meal, a gift card, entry into a drawing — and
+     * whenever they are staff, family or an owner. Rendered with the quote, not
+     * in a page footer: the disclosure has to be where the claim is.
+     * e.g. "Received a free meal in exchange for this review."
+     */
+    disclosure?: string;
+};
+/** Per-slot Tailwind classes for the testimonials block. */
+type TestimonialsItemClasses = Partial<{
+    section: string;
+    title: string;
+    list: string;
+    card: string;
+    stars: string;
+    star: string;
+    starEmpty: string;
+    quote: string;
+    attribution: string;
+    name: string;
+    detail: string;
+    disclosure: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeTestimonialsItemClasses}.
+ *
+ * No line clamp on `quote`, deliberately: a card that cuts a testimonial off
+ * mid-sentence is publishing an edit of it. Long quotes make a taller card,
+ * which is the correct outcome.
+ */
+declare const TESTIMONIALS_DEFAULT_ITEM_CLASSES: Required<TestimonialsItemClasses>;
+declare function mergeTestimonialsItemClasses(overrides?: TestimonialsItemClasses): {
+    section: string;
+    title: string;
+    list: string;
+    card: string;
+    stars: string;
+    star: string;
+    starEmpty: string;
+    quote: string;
+    attribution: string;
+    name: string;
+    detail: string;
+    disclosure: string;
+};
+type TestimonialsProps = {
+    testimonials: Testimonial[];
+    title?: string;
+    itemClasses?: TestimonialsItemClasses;
+};
+/**
+ * What customers said, in their own words, attributed.
+ *
+ * Deliberately emits no `Review` or `AggregateRating` JSON-LD. Since 2019
+ * Google ignores reviews a business collects about itself on its own site —
+ * they are ineligible for review rich results either way — so the markup buys
+ * no stars in search and only adds a structured-data policy surface to get
+ * wrong. The stars here are for the reader.
+ */
+declare function Testimonials({ testimonials, title, itemClasses }: TestimonialsProps): react_jsx_runtime.JSX.Element | null;
+
+/** Per-slot Tailwind classes for the category tile grid. */
+type CategoryTilesItemClasses = Partial<{
+    baseContainer: string;
+    title: string;
+    tiles: string;
+    tile: string;
+    tileImage: string;
+    tileName: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeCategoryTilesItemClasses}.
+ */
+declare const CATEGORY_TILES_DEFAULT_ITEM_CLASSES: Required<CategoryTilesItemClasses>;
+declare function mergeCategoryTilesItemClasses(overrides?: CategoryTilesItemClasses): {
+    baseContainer: string;
+    title: string;
+    tiles: string;
+    tile: string;
+    tileImage: string;
+    tileName: string;
+};
+/** The `/menu#pizzas` anchor for a category — the same id the menu page's
+ *  category sections carry. */
+declare function categoryAnchor(name: string): string;
+type CategoryTilesProps = {
+    menu: Menu;
+    title?: string;
+    /** Menu page the anchors point at. */
+    menuHref?: string;
+    itemClasses?: CategoryTilesItemClasses;
+    sizes?: string;
+};
+/**
+ * One tile per menu category, linking to that category on the menu page. Each
+ * tile borrows the photo of the first item in the category that has one, so a
+ * category of photo-less items still renders as a typographic tile.
+ *
+ * Empty categories are skipped; nothing renders when none are left.
+ */
+declare function CategoryTiles({ menu, title, menuHref, itemClasses, sizes, }: CategoryTilesProps): react_jsx_runtime.JSX.Element | null;
+
+/** Per-slot Tailwind classes for a page section. */
+type SectionItemClasses = Partial<{
+    container: string;
+    eyebrow: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeSectionItemClasses}.
+ *
+ * SP-01/02: one spacing scale and one container width for every section, so
+ * left edges line up while scrolling instead of each section picking its own.
+ * SP-03: the eyebrow gets full padding above (it's the top of a new section)
+ * and a tight gap below (it labels what follows, not what came before).
+ */
+declare const SECTION_DEFAULT_ITEM_CLASSES: Required<SectionItemClasses>;
+declare function mergeSectionItemClasses(overrides?: SectionItemClasses): {
+    container: string;
+    eyebrow: string;
+};
+type SectionProps = {
+    itemClasses?: SectionItemClasses;
+    /** e.g. "BY DEFAULT, OUR TRUCK INCLUDES" — rendered above `children`, inside the same padded container so it never floats free of what it labels. */
+    eyebrow?: ReactNode;
+    children: ReactNode;
+    id?: string;
+};
+/** One page section: consistent container width and vertical rhythm, with an optional eyebrow label. */
+declare function Section({ itemClasses, eyebrow, children, id }: SectionProps): react_jsx_runtime.JSX.Element;
+
+type PageHeroSize = "sm" | "md" | "lg";
+/** Per-slot Tailwind classes for a page hero. */
+type PageHeroItemClasses = Partial<{
+    container: string;
+    imageBox: string;
+    image: string;
+    titleContainer: string;
+    title: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergePageHeroItemClasses}.
+ */
+declare const PAGE_HERO_DEFAULT_ITEM_CLASSES: Required<PageHeroItemClasses>;
+declare function mergePageHeroItemClasses(overrides?: PageHeroItemClasses): {
+    container: string;
+    imageBox: string;
+    image: string;
+    titleContainer: string;
+    title: string;
+};
+/**
+ * HD-01/02: a real height scale instead of the ~240px letterbox every hero on
+ * the old site collapsed to (which read as a divider, not a hero). Tailwind's
+ * default spacing scale only — no arbitrary pixel/vh values, which is the
+ * exact smell this checklist exists to cure.
+ */
+declare function heroHeightClass(size: PageHeroSize): string;
+/**
+ * MB-03: a title over a small hero needs its own mobile step, not the desktop
+ * size scaled down with `clamp()` — each size gets a dedicated mobile/desktop
+ * pair from the type scale.
+ */
+declare function heroTitleTypeClass(size: PageHeroSize): string;
+type PageHeroProps = {
+    size?: PageHeroSize;
+    image: {
+        src: string;
+        alt: string;
+    };
+    /** HD-03: photography carries the top of the page by default. Pass a title only for the rare page that needs text over the hero. */
+    title?: ReactNode;
+    priority?: boolean;
+    itemClasses?: PageHeroItemClasses;
+};
+/** A page-top hero: an art-directed photo with a defined bottom edge and, by default, no title competing with it. */
+declare function PageHero({ size, image, title, priority, itemClasses }: PageHeroProps): react_jsx_runtime.JSX.Element;
+
+/** Per-slot Tailwind classes for a nav link. */
+type NavLinkItemClasses = Partial<{
+    base: string;
+    active: string;
+    inactive: string;
+}>;
+/**
+ * Structural / theme defaults. Merged with `itemClasses` via
+ * {@link mergeNavLinkItemClasses}.
+ *
+ * NV-01: links default to `text-foreground` (the derived near-black/near-white
+ * token every franchise already gets), not a second hardcoded gray — the
+ * checklist's "near-black" is what that token already resolves to on a light
+ * background. Red is reserved for hover/active so the one red "Order Online"
+ * pill stays the visually distinct primary action.
+ */
+declare const NAV_LINK_DEFAULT_ITEM_CLASSES: Required<NavLinkItemClasses>;
+declare function mergeNavLinkItemClasses(overrides?: NavLinkItemClasses): {
+    base: string;
+    inactive: string;
+    active: string;
+};
+/**
+ * NV-02: the current page gets the active indicator, nothing else does.
+ * "/" gets an exact match — every pathname starts with "/", so a prefix match
+ * would leave the home link permanently active. Everything else is a prefix
+ * match so a link to /menu also lights up on /menu/gyro.
+ */
+declare function isNavLinkActive(pathname: string, href: string): boolean;
+type NavLinkProps = {
+    href: string;
+    itemClasses?: NavLinkItemClasses;
+    children: ReactNode;
+} & Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href" | "className">;
+/** A header nav link: near-black by default, red on hover or on the active page, with an active-page indicator. */
+declare function NavLink({ href, itemClasses, children, ...rest }: NavLinkProps): react_jsx_runtime.JSX.Element;
+
+export { ACCORDION_MENU_DEFAULT_ITEM_CLASSES, AccordionMenu, type AccordionMenuItemClasses, AccordionSection, type AccordionSectionSlots, BREADCRUMBS_DEFAULT_ITEM_CLASSES, BUTTON_DEFAULT_ITEM_CLASSES, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsItemClasses, Button, type ButtonItemClasses, type ButtonProps, type ButtonVariant, type ButtonWidth, CATEGORY_TILES_DEFAULT_ITEM_CLASSES, CHECKOUT_FORM_DEFAULT_ITEM_CLASSES, CHECKOUT_FORM_SLOTS, CHECKOUT_HOLD_COPY, CLIENT_ITEM_FORM_DEFAULT_ITEM_CLASSES, CLIENT_ITEM_FORM_SLOTS, CategoryTiles, type CategoryTilesItemClasses, type CategoryTilesProps, CheckoutForm, type CheckoutFormItemClasses, type CheckoutFormSlots, type CheckoutHoldCopy, CheckoutShell, CheckoutSteps, ClientItemForm, type ClientItemFormItemClasses, type ClientItemFormSlots, CommentsSection, ComponentsSection, ConsentFields, ContactFields, CookieConsent, DetailsStep, FAQ_ACCORDION_DEFAULT_ITEM_CLASSES, FIND_LOCATION_DEFAULT_ITEM_CLASSES, type Faq, FaqAccordion, type FaqAccordionItemClasses, type FaqAccordionProps, FindLocation, type FindLocationItemClasses, GALLERY_DEFAULT_ITEM_CLASSES, GRID_MENU_DEFAULT_ITEM_CLASSES, Gallery, type GalleryImage, type GalleryItemClasses, type GalleryProps, GridMenu, type GridMenuItemClasses, ITEM_CARD_DEFAULT_ITEM_CLASSES, CLIENT_ITEM_FORM_DEFAULT_ITEM_CLASSES as ITEM_CUSTOMIZATION_FORM_DEFAULT_ITEM_CLASSES, ItemCard, type ItemCardItemClasses, type ItemCardProps, ClientItemForm as ItemCustomizationClient, ClientItemForm as ItemCustomizationForm, type ClientItemFormItemClasses as ItemCustomizationFormItemClasses, LOCATION_CARD_DEFAULT_ITEM_CLASSES, LocationCard, type LocationCardItemClasses, type LocationCardProps, LocationsSection, type LocationsSectionProps, NAV_LINK_DEFAULT_ITEM_CLASSES, NavLink, type NavLinkItemClasses, type NavLinkProps, OPEN_STATUS_DEFAULT_ITEM_CLASSES, OpenStatus, type OpenStatusItemClasses, type OpenStatusProps, OptionButton, OrderLine, OrderLines, OrderTotals, PAGE_HERO_DEFAULT_ITEM_CLASSES, PageHero, type PageHeroItemClasses, type PageHeroProps, type PageHeroSize, PaymentStep, PortionPicker, type PortionPickerProps, PortionSection, type PortionShapeProps, PromoCode, QuantitySection, RuleSection, SECTION_DEFAULT_ITEM_CLASSES, STICKY_BUTTON_DEFAULT_BAR_CLASS, Section, type SectionItemClasses, type SectionProps, StatusPanel, StickyButton, type StickyButtonItemClasses, type StickyButtonProps, SubmitButton, TESTIMONIALS_DEFAULT_ITEM_CLASSES, type Testimonial, Testimonials, type TestimonialsItemClasses, type TestimonialsProps, VariantSection, buttonWidthClass, categoryAnchor, heroHeightClass, heroTitleTypeClass, isNavLinkActive, isStickyRoute, locationGridClass, locationMap, mergeAccordionMenuItemClasses, mergeBreadcrumbsItemClasses, mergeButtonItemClasses, mergeCategoryTilesItemClasses, mergeCheckoutFormItemClasses, mergeClientItemFormItemClasses, mergeFaqAccordionItemClasses, mergeFindLocationItemClasses, mergeGalleryItemClasses, mergeGridMenuItemClasses, mergeItemCardItemClasses, mergeClientItemFormItemClasses as mergeItemCustomizationFormItemClasses, mergeLocationCardItemClasses, mergeNavLinkItemClasses, mergeOpenStatusItemClasses, mergePageHeroItemClasses, mergeSectionItemClasses, mergeTestimonialsItemClasses, money, openStatus };