@nok-integration/storefront-react 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,3530 @@
+import { AnchorHTMLAttributes } from 'react';
+import { ButtonHTMLAttributes } from 'react';
+import { ComponentPropsWithoutRef } from 'react';
+import { CSSProperties } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { JSX } from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { z } from 'zod';
+
+/** `POST /v1/cart/items` — add an item. */
+declare const AddCartItemRequest: z.ZodObject<{
+    sku: z.ZodString;
+    qty: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    sku: string;
+    qty: number;
+}, {
+    sku: string;
+    qty: number;
+}>;
+
+declare type AddCartItemRequest = z.infer<typeof AddCartItemRequest>;
+
+/** The `error` member — a machine `code`, a human `message`, and optional `details`. */
+declare const ApiErrorBody: z.ZodObject<{
+    code: z.ZodEnum<["invalid_request", "unauthorized", "out_of_stock", "cart_locked", "sku_not_found", "category_not_found", "amount_mismatch", "duplicate_order", "order_not_found", "order_not_cancellable", "forbidden", "invalid_transition", "rate_limited", "server_error"]>;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    code: "invalid_request" | "unauthorized" | "out_of_stock" | "cart_locked" | "sku_not_found" | "category_not_found" | "amount_mismatch" | "duplicate_order" | "order_not_found" | "order_not_cancellable" | "forbidden" | "invalid_transition" | "rate_limited" | "server_error";
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}, {
+    code: "invalid_request" | "unauthorized" | "out_of_stock" | "cart_locked" | "sku_not_found" | "category_not_found" | "amount_mismatch" | "duplicate_order" | "order_not_found" | "order_not_cancellable" | "forbidden" | "invalid_transition" | "rate_limited" | "server_error";
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}>;
+
+declare type ApiErrorBody = z.infer<typeof ApiErrorBody>;
+
+/**
+ * Narrow an unknown thrown value to the typed API error, if it is one.
+ *
+ * **Structural, not `instanceof`.** The identity check looks obviously correct and is
+ * wrong across a bundle boundary: the standalone distribution embeds its own copy of the
+ * client, so an error thrown inside the SDK is not an `instanceof` the `DaznApiError`
+ * a host imported separately — and vice versa. Every branch silently falls through to
+ * "unknown error", which is the worst possible failure for error handling because it
+ * still *works*, just always wrongly.
+ *
+ * Found by consuming the built package instead of the source. Against source there is
+ * one class and `instanceof` passes.
+ */
+export declare function asApiError(err: unknown): DaznApiError | undefined;
+
+/** Small status/label pill. */
+export declare function Badge({ tone, children }: BadgeProps): JSX.Element;
+
+export declare interface BadgeProps {
+    tone?: BadgeTone;
+    children: ReactNode;
+}
+
+export declare type BadgeTone = 'neutral' | 'success' | 'critical' | 'promo';
+
+export declare function BottomSheet({ open, onClose, title, children, footer }: BottomSheetProps): JSX.Element | null;
+
+export declare interface BottomSheetProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    children: ReactNode;
+    /** Optional sticky footer (e.g. a StickyCtaBar). */
+    footer?: ReactNode;
+}
+
+/**
+ * Primary/secondary/ghost button. ≥44px tap target, visible focus, disabled and
+ * loading states. Loading sets `aria-busy` and blocks clicks without collapsing size.
+ */
+export declare const Button: ForwardRefExoticComponent<ButtonProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    /** Shows a spinner and marks the control busy; also disables interaction. */
+    loading?: boolean;
+    fullWidth?: boolean;
+}
+
+export declare type ButtonVariant = 'primary' | 'secondary' | 'ghost';
+
+/** A line in the cart. `line_total` = `unit_price` × `qty`, in the cart currency. */
+declare const CartItem: z.ZodObject<{
+    sku: z.ZodString;
+    qty: z.ZodNumber;
+    unit_price: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+    line_total: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+    /**
+     * Product title for this line, e.g. "Signature Hoodie".
+     *
+     * **Display only**, and the reason it exists: without it a cart can only render the
+     * `sku`, and a SKU is an internal identifier, not something to show a fan. A consumer
+     * must not parse it, match on it, or treat it as stable — it is whatever the catalogue
+     * says today, and it is localised with the rest of the catalogue.
+     *
+     * Optional because it is projected from the catalogue read model, which is a cache: a
+     * SKU that has been de-listed since it entered the cart still has a line, and a
+     * fabricated title would be worse than none. Absent = the consumer falls back to
+     * whatever it can show, and the line still prices and checks out correctly.
+     */
+    title: z.ZodOptional<z.ZodString>;
+    /**
+     * Line thumbnail — the variant image where the variant has one, otherwise the
+     * product's first media entry. Absent = render a neutral placeholder; never
+     * substitute another product's image.
+     */
+    image: z.ZodOptional<z.ZodString>;
+    /**
+     * The variant's defining attributes, e.g. `{ size: 'M', colour: 'Black' }`. Mirrors
+     * {@link ProductVariant.attributes}, so a consumer reads one shape everywhere.
+     *
+     * Sent as the raw map rather than a pre-composed "M · Black" string on purpose. The
+     * separator, the order and the casing are presentation, and the engine has no business
+     * choosing them for a host that may render size and colour as separate chips. Two
+     * lines differing only by size are otherwise indistinguishable in the cart, which is
+     * the bug this field exists to fix.
+     */
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /**
+     * Optional stock ceiling for this line, so the quantity stepper can cap the increment
+     * and tell the fan *why* instead of silently refusing. Mirrors
+     * {@link ProductVariant.available}.
+     *
+     * **Display only, and a hint.** The projection is a cache and the authoritative check
+     * runs at checkout (DAZN's, under ADR-0008) — a consumer must not treat this as a
+     * guarantee that N are purchasable. Absent = impose no cap client-side; the engine
+     * still rejects an over-quantity update with `out_of_stock`, which carries the real
+     * `available` figure in its error details.
+     */
+    available: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sku: string;
+    qty: number;
+    unit_price: {
+        amount: number;
+        currency: string;
+    };
+    line_total: {
+        amount: number;
+        currency: string;
+    };
+    title?: string | undefined;
+    image?: string | undefined;
+    attributes?: Record<string, string> | undefined;
+    available?: number | undefined;
+}, {
+    sku: string;
+    qty: number;
+    unit_price: {
+        amount: number;
+        currency: string;
+    };
+    line_total: {
+        amount: number;
+        currency: string;
+    };
+    title?: string | undefined;
+    image?: string | undefined;
+    attributes?: Record<string, string> | undefined;
+    available?: number | undefined;
+}>;
+
+declare type CartItem = z.infer<typeof CartItem>;
+
+/**
+ * A single cart line: media, title, variant, unit price, qty stepper, and line total.
+ *
+ * Title, image and variant come from the line itself (contracts 2.15.0). Before that the
+ * wire carried only a SKU, so this rendered an internal code against an empty grey box —
+ * and two sizes of one product were indistinguishable.
+ *
+ * All three stay optional, because the catalogue projection is a cache: a SKU de-listed
+ * after it entered the cart still has a line. It degrades rather than breaks — the SKU
+ * stands in for a missing title, and a missing image leaves the placeholder — so the fan
+ * can always still read the price and remove the line.
+ */
+export declare function CartLineItem({ item, title, image, maxQty, onQtyChange, onRemove, pending, }: CartLineItemProps): JSX.Element;
+
+export declare interface CartLineItemProps {
+    item: CartItem;
+    /**
+     * Override the line's own title/image (contracts 2.15.0). Escape hatches for a host
+     * with richer catalogue data than the cart carries — not the normal path, and not
+     * required for the line to render properly.
+     */
+    title?: string;
+    image?: string;
+    maxQty?: number;
+    onQtyChange: (qty: number) => void;
+    onRemove: () => void;
+    pending?: boolean;
+}
+
+declare interface CartSheetApi {
+    open: () => void;
+    close: () => void;
+    isOpen: boolean;
+}
+
+/**
+ * Presents the cart as a bottom sheet over the current screen, so adding to
+ * the cart never costs the fan their place in the catalogue.
+ *
+ * The `/cart` route still renders the same {@link CartView} — this is a second
+ * presentation of one component, not a second cart. Both read the session cart from the
+ * engine, so they cannot disagree.
+ */
+declare function CartSheetProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+export { CartSheetProvider as CartSheet }
+export { CartSheetProvider }
+
+/**
+ * Opens the cart as a bottom sheet.
+ *
+ * Falls back to a link to `/cart` when no {@link CartSheetProvider} is above it, so the
+ * cart is always reachable — including with JS unavailable, where the anchor still
+ * navigates. The route renders the same CartView, so the fallback is the same cart, not
+ * a degraded one.
+ */
+export declare function CartTrigger({ className, children, ...rest }: CartTriggerProps): JSX.Element;
+
+export declare interface CartTriggerProps {
+    className?: string;
+    children: ReactNode;
+    'aria-label'?: string;
+}
+
+/**
+ * The CTA needs no prop to work in both presentations: StickyCtaBar is
+ * `position: sticky; bottom: 0`, so on the page it pins to the viewport and inside the
+ * sheet it pins to the bottom of the sheet's scrolling body. Same component, same
+ * safe-area handling, no branch.
+ */
+export declare function CartView(props?: CartViewProps): JSX.Element;
+
+/**
+ * 4.4 Cart. Loads the session cart, supports optimistic + idempotent qty/remove edits
+ * (reverting on error), and hands off to checkout.
+ *
+ * There is no `withSession` wrapper here any more. Re-authentication moved down into the
+ * SDK's transport, which asks the host's `getToken()` once on a `401` and retries — so
+ * every component gets that behaviour without remembering to opt in, and a component
+ * that forgets can no longer quietly lose it.
+ */
+export declare interface CartViewProps {
+    /**
+     * Dismiss the containing sheet. Supplied when the cart is presented as a
+     * BottomSheet; omitted on the `/cart` route, where there is nothing to dismiss.
+     */
+    onContinueShopping?: () => void;
+    /**
+     * Label for the primary CTA. Default `Proceed to checkout`.
+     *
+     * DAZN's checkout is the next step and DAZN name it; a host whose own wording is
+     * "Continue" or "Go to checkout" should not have to accept ours. The locked-cart label
+     * is deliberately NOT configurable — it states a condition rather than an action, and a
+     * host renaming it could imply the button still works.
+     */
+    checkoutLabel?: string;
+}
+
+/**
+ * Query params for the single-product, recommendations and category-page reads — market
+ * context only. A separate alias (rather than reusing {@link MarketQuery} directly) so
+ * these endpoints can gain their own params later without touching the shared object.
+ */
+declare const CatalogReadQuery: z.ZodObject<{
+    country: z.ZodOptional<z.ZodString>;
+    lang: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    country?: string | undefined;
+    lang?: string | undefined;
+}, {
+    country?: string | undefined;
+    lang?: string | undefined;
+}>;
+
+declare type CatalogReadQuery = z.infer<typeof CatalogReadQuery>;
+
+/**
+ * 4.2 Category (PCP) — the composed screen, given a page that is already fetched.
+ *
+ * This exists for the same reason `ProductDetail` does: the presentation belongs to the
+ * package, so that the fetching wrapper around it — `CategoryView` here, an RSC route in
+ * our own app — is only ever fetching. It was previously written out twice, once in each,
+ * and the two drifted: the SDK copy rendered a bare `div`/`section`/`ul` tree with none of
+ * the page layout, so a host mounting `CategoryView` got correctly styled blocks stacked
+ * with no column spacing, no page background, and a full-bleed one-column "grid". The
+ * blocks looked right individually, which is what made it read as a missing stylesheet
+ * rather than a missing wrapper.
+ *
+ * Not a client component: it renders no interactivity of its own, so it stays usable
+ * directly from a server component. The pieces that do need the client carry their own
+ * `'use client'`.
+ */
+export declare function CategoryContent({ page }: CategoryContentProps): JSX.Element;
+
+export declare interface CategoryContentProps {
+    /** An already-fetched category page. */
+    page: CategoryPage;
+}
+
+/**
+ * `GET /v1/catalog/categories/{code}/page` — the CMS-authored content for a category
+ * landing page (PCP). A page is a hero plus an **ordered list of typed blocks**, so
+ * merchandisers can compose editorial + product sections freely. Product blocks embed
+ * resolved {@link Product}s so the storefront renders without a second round-trip.
+ */
+declare const CategoryHero: z.ZodObject<{
+    title: z.ZodString;
+    subtitle: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    image?: string | undefined;
+    subtitle?: string | undefined;
+}, {
+    title: string;
+    image?: string | undefined;
+    subtitle?: string | undefined;
+}>;
+
+declare type CategoryHero = z.infer<typeof CategoryHero>;
+
+declare const CategoryPage: z.ZodObject<{
+    code: z.ZodString;
+    hero: z.ZodObject<{
+        title: z.ZodString;
+        subtitle: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        image?: string | undefined;
+        subtitle?: string | undefined;
+    }, {
+        title: string;
+        image?: string | undefined;
+        subtitle?: string | undefined;
+    }>;
+    blocks: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"rail">;
+        title: z.ZodString;
+        products: z.ZodArray<z.ZodObject<{
+            sku: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            price: z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                amount: number;
+                currency: string;
+            }, {
+                amount: number;
+                currency: string;
+            }>;
+            compare_at: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                amount: number;
+                currency: string;
+            }, {
+                amount: number;
+                currency: string;
+            }>>;
+            media: z.ZodArray<z.ZodString, "many">;
+            variants: z.ZodArray<z.ZodObject<{
+                sku: z.ZodString;
+                attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+                in_stock: z.ZodBoolean;
+                image: z.ZodOptional<z.ZodString>;
+                available: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }, {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }>, "many">;
+            description: z.ZodOptional<z.ZodString>;
+            badges: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            promo: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                ends_at: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                ends_at?: string | undefined;
+            }, {
+                message: string;
+                ends_at?: string | undefined;
+            }>>;
+            size_guide: z.ZodOptional<z.ZodObject<{
+                title: z.ZodString;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                rows: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+                notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            }, {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }, {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        kind: "rail";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    }, {
+        title: string;
+        kind: "rail";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"lifestyle_text">;
+        text: z.ZodString;
+        align: z.ZodDefault<z.ZodEnum<["center", "left"]>>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "lifestyle_text";
+        text: string;
+        align: "center" | "left";
+    }, {
+        kind: "lifestyle_text";
+        text: string;
+        align?: "center" | "left" | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"featured">;
+        product: z.ZodObject<{
+            sku: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            price: z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                amount: number;
+                currency: string;
+            }, {
+                amount: number;
+                currency: string;
+            }>;
+            compare_at: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                amount: number;
+                currency: string;
+            }, {
+                amount: number;
+                currency: string;
+            }>>;
+            media: z.ZodArray<z.ZodString, "many">;
+            variants: z.ZodArray<z.ZodObject<{
+                sku: z.ZodString;
+                attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+                in_stock: z.ZodBoolean;
+                image: z.ZodOptional<z.ZodString>;
+                available: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }, {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }>, "many">;
+            description: z.ZodOptional<z.ZodString>;
+            badges: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            promo: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                ends_at: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                ends_at?: string | undefined;
+            }, {
+                message: string;
+                ends_at?: string | undefined;
+            }>>;
+            size_guide: z.ZodOptional<z.ZodObject<{
+                title: z.ZodString;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                rows: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+                notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            }, {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }, {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "featured";
+        product: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        };
+    }, {
+        kind: "featured";
+        product: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        };
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"lifestyle_image">;
+        images: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "lifestyle_image";
+        images: string[];
+    }, {
+        kind: "lifestyle_image";
+        images: string[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"grid">;
+        title: z.ZodString;
+        products: z.ZodArray<z.ZodObject<{
+            sku: z.ZodString;
+            title: z.ZodString;
+            category: z.ZodString;
+            price: z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                amount: number;
+                currency: string;
+            }, {
+                amount: number;
+                currency: string;
+            }>;
+            compare_at: z.ZodOptional<z.ZodObject<{
+                amount: z.ZodNumber;
+                currency: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                amount: number;
+                currency: string;
+            }, {
+                amount: number;
+                currency: string;
+            }>>;
+            media: z.ZodArray<z.ZodString, "many">;
+            variants: z.ZodArray<z.ZodObject<{
+                sku: z.ZodString;
+                attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+                in_stock: z.ZodBoolean;
+                image: z.ZodOptional<z.ZodString>;
+                available: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }, {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }>, "many">;
+            description: z.ZodOptional<z.ZodString>;
+            badges: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            promo: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                ends_at: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                message: string;
+                ends_at?: string | undefined;
+            }, {
+                message: string;
+                ends_at?: string | undefined;
+            }>>;
+            size_guide: z.ZodOptional<z.ZodObject<{
+                title: z.ZodString;
+                columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                rows: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+                notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            }, {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }, {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        kind: "grid";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    }, {
+        title: string;
+        kind: "grid";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"review">;
+        quotes: z.ZodArray<z.ZodObject<{
+            quote: z.ZodString;
+            author: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            quote: string;
+            author: string;
+        }, {
+            quote: string;
+            author: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "review";
+        quotes: {
+            quote: string;
+            author: string;
+        }[];
+    }, {
+        kind: "review";
+        quotes: {
+            quote: string;
+            author: string;
+        }[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"why_us">;
+        items: z.ZodArray<z.ZodObject<{
+            icon: z.ZodOptional<z.ZodEnum<["payment", "delivery", "returns"]>>;
+            title: z.ZodString;
+            body: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            body: string;
+            icon?: "payment" | "delivery" | "returns" | undefined;
+        }, {
+            title: string;
+            body: string;
+            icon?: "payment" | "delivery" | "returns" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        items: {
+            title: string;
+            body: string;
+            icon?: "payment" | "delivery" | "returns" | undefined;
+        }[];
+        kind: "why_us";
+    }, {
+        items: {
+            title: string;
+            body: string;
+            icon?: "payment" | "delivery" | "returns" | undefined;
+        }[];
+        kind: "why_us";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"explore">;
+        title: z.ZodString;
+        links: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            code: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            label: string;
+        }, {
+            code: string;
+            label: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        kind: "explore";
+        links: {
+            code: string;
+            label: string;
+        }[];
+    }, {
+        title: string;
+        kind: "explore";
+        links: {
+            code: string;
+            label: string;
+        }[];
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    hero: {
+        title: string;
+        image?: string | undefined;
+        subtitle?: string | undefined;
+    };
+    blocks: ({
+        title: string;
+        kind: "rail";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    } | {
+        kind: "lifestyle_text";
+        text: string;
+        align: "center" | "left";
+    } | {
+        kind: "featured";
+        product: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        };
+    } | {
+        kind: "lifestyle_image";
+        images: string[];
+    } | {
+        title: string;
+        kind: "grid";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    } | {
+        kind: "review";
+        quotes: {
+            quote: string;
+            author: string;
+        }[];
+    } | {
+        items: {
+            title: string;
+            body: string;
+            icon?: "payment" | "delivery" | "returns" | undefined;
+        }[];
+        kind: "why_us";
+    } | {
+        title: string;
+        kind: "explore";
+        links: {
+            code: string;
+            label: string;
+        }[];
+    })[];
+}, {
+    code: string;
+    hero: {
+        title: string;
+        image?: string | undefined;
+        subtitle?: string | undefined;
+    };
+    blocks: ({
+        title: string;
+        kind: "rail";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    } | {
+        kind: "lifestyle_text";
+        text: string;
+        align?: "center" | "left" | undefined;
+    } | {
+        kind: "featured";
+        product: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        };
+    } | {
+        kind: "lifestyle_image";
+        images: string[];
+    } | {
+        title: string;
+        kind: "grid";
+        products: {
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }[];
+    } | {
+        kind: "review";
+        quotes: {
+            quote: string;
+            author: string;
+        }[];
+    } | {
+        items: {
+            title: string;
+            body: string;
+            icon?: "payment" | "delivery" | "returns" | undefined;
+        }[];
+        kind: "why_us";
+    } | {
+        title: string;
+        kind: "explore";
+        links: {
+            code: string;
+            label: string;
+        }[];
+    })[];
+}>;
+
+declare type CategoryPage = z.infer<typeof CategoryPage>;
+
+/**
+ * A whole category screen, data fetching included — a **level 1 view**.
+ *
+ * This is the smallest integration surface a host can take: give it a code, it renders,
+ * and it owns its own loading, empty and error states. The screen itself is
+ * {@link CategoryContent}; everything it is built from (`RailCarousel`, `ProductTile`, …)
+ * stays exported for a host that would rather compose and fetch it themselves.
+ *
+ * Fetching happens on mount, client-side, through the provider's client — so it inherits
+ * the host's session and market without being told about either.
+ */
+export declare function CategoryView({ code, initialData, onNotFound }: CategoryViewProps): JSX.Element;
+
+export declare interface CategoryViewProps {
+    /** Category code — the leaf, e.g. `hoodies`. */
+    code: string;
+    /**
+     * An already-fetched page, from a host that server-rendered this screen. Painted
+     * synchronously on the first frame — no skeleton, no waterfall — and revalidated in the
+     * background, because a server-rendered page can be arbitrarily old by the time it is
+     * interactive and price and availability are the two things worst served by being stale.
+     */
+    initialData?: CategoryPage;
+    /**
+     * Replaces the built-in empty state when the category does not exist, so a host can
+     * render their own 404 in their own chrome. Only for `category_not_found`: a genuine
+     * fault still renders the recoverable error state, because inviting a retry is right
+     * there and wrong for a category that is gone.
+     */
+    onNotFound?: () => ReactNode;
+}
+
+declare interface ClientOptions {
+    /** The `/v1` base URL, e.g. `https://storefront.example.com/v1`. */
+    baseUrl: string;
+    /** Override the fetch implementation (defaults to the global `fetch`). */
+    fetch?: typeof fetch;
+    /** Supplies the session bearer token, if not relying solely on the session cookie. */
+    getToken?: () => string | undefined | Promise<string | undefined>;
+    /** Extra headers applied to every request. */
+    defaultHeaders?: Record<string, string>;
+    /** Credentials mode (browser); defaults to `include` so the session cookie is sent. */
+    credentials?: RequestCredentials;
+}
+
+/** Extract the API error `code` from a thrown value, if present. */
+export declare function codeOf(err: unknown): ErrorCode | undefined;
+
+/**
+ * PDP colour selector (Figma `mobile/pdp/color`): a "Colour: <name>" header and a row of
+ * 79×105 image tiles. The selected tile gets a dark border; sold-out colours are disabled
+ * with an overlay. A real radiogroup for keyboard + screen-reader support.
+ */
+export declare function ColorSelector({ colours, selected, onSelect }: ColorSelectorProps): JSX.Element;
+
+export declare interface ColorSelectorProps {
+    colours: ColourOption[];
+    /** Selected colour value, or null when none is chosen yet. */
+    selected: string | null;
+    onSelect: (value: string) => void;
+}
+
+/** The attribute key a product uses for colour, if any (`colour` or `color`). */
+export declare function colourKeyOf(variants: ProductVariant[]): string | null;
+
+export declare interface ColourOption {
+    value: string;
+    available: boolean;
+    image?: string;
+    /** Remaining stock for this colour (summed across in-stock sizes); drives "N left". */
+    remaining?: number;
+}
+
+/**
+ * Distinct colours with a representative image and remaining stock. `available` and
+ * `remaining` are filtered to the given size when one is selected.
+ */
+export declare function colourOptions(variants: ProductVariant[], size?: string | null): ColourOption[];
+
+/**
+ * A typed, schema-validating client for the `/v1` API. Every response is parsed with
+ * its contract schema; a non-2xx response throws a {@link DaznApiError}.
+ */
+declare function createClient(options: ClientOptions): {
+    catalog: {
+        listProducts: (query?: ListProductsQuery) => Promise<{
+            data: {
+                sku: string;
+                title: string;
+                category: string;
+                price: {
+                    amount: number;
+                    currency: string;
+                };
+                media: string[];
+                variants: {
+                    sku: string;
+                    attributes: Record<string, string>;
+                    in_stock: boolean;
+                    image?: string | undefined;
+                    available?: number | undefined;
+                }[];
+                compare_at?: {
+                    amount: number;
+                    currency: string;
+                } | undefined;
+                description?: string | undefined;
+                badges?: string[] | undefined;
+                promo?: {
+                    message: string;
+                    ends_at?: string | undefined;
+                } | undefined;
+                size_guide?: {
+                    title: string;
+                    columns?: string[] | undefined;
+                    rows?: string[][] | undefined;
+                    notes?: string[] | undefined;
+                } | undefined;
+            }[];
+            page: {
+                cursor: string | null;
+                has_more: boolean;
+            };
+        }>;
+        getProduct: (sku: string, query?: CatalogReadQuery) => Promise<{
+            sku: string;
+            title: string;
+            category: string;
+            price: {
+                amount: number;
+                currency: string;
+            };
+            media: string[];
+            variants: {
+                sku: string;
+                attributes: Record<string, string>;
+                in_stock: boolean;
+                image?: string | undefined;
+                available?: number | undefined;
+            }[];
+            compare_at?: {
+                amount: number;
+                currency: string;
+            } | undefined;
+            description?: string | undefined;
+            badges?: string[] | undefined;
+            promo?: {
+                message: string;
+                ends_at?: string | undefined;
+            } | undefined;
+            size_guide?: {
+                title: string;
+                columns?: string[] | undefined;
+                rows?: string[][] | undefined;
+                notes?: string[] | undefined;
+            } | undefined;
+        }>;
+        getRecommendations: (sku: string, query?: CatalogReadQuery) => Promise<{
+            data: {
+                sku: string;
+                title: string;
+                category: string;
+                price: {
+                    amount: number;
+                    currency: string;
+                };
+                media: string[];
+                variants: {
+                    sku: string;
+                    attributes: Record<string, string>;
+                    in_stock: boolean;
+                    image?: string | undefined;
+                    available?: number | undefined;
+                }[];
+                compare_at?: {
+                    amount: number;
+                    currency: string;
+                } | undefined;
+                description?: string | undefined;
+                badges?: string[] | undefined;
+                promo?: {
+                    message: string;
+                    ends_at?: string | undefined;
+                } | undefined;
+                size_guide?: {
+                    title: string;
+                    columns?: string[] | undefined;
+                    rows?: string[][] | undefined;
+                    notes?: string[] | undefined;
+                } | undefined;
+            }[];
+        }>;
+        /**
+         * The code travels as a QUERY parameter, not a path segment.
+         *
+         * Category codes contain a slash, which in a path segment must be sent as `%2F` —
+         * and Apache rejects that by default (`AllowEncodedSlashes Off`), returning its own
+         * HTML 404 before the request reaches the API at all. Every real category code has
+         * a slash in it, so the path form served none of them.
+         *
+         * The engine still exposes the path form for slash-free codes; this client does not
+         * use it, because a query parameter works regardless of how any proxy in the chain
+         * is configured.
+         */
+        getCategoryPage: (code: string, query?: CatalogReadQuery) => Promise<{
+            code: string;
+            hero: {
+                title: string;
+                image?: string | undefined;
+                subtitle?: string | undefined;
+            };
+            blocks: ({
+                title: string;
+                kind: "rail";
+                products: {
+                    sku: string;
+                    title: string;
+                    category: string;
+                    price: {
+                        amount: number;
+                        currency: string;
+                    };
+                    media: string[];
+                    variants: {
+                        sku: string;
+                        attributes: Record<string, string>;
+                        in_stock: boolean;
+                        image?: string | undefined;
+                        available?: number | undefined;
+                    }[];
+                    compare_at?: {
+                        amount: number;
+                        currency: string;
+                    } | undefined;
+                    description?: string | undefined;
+                    badges?: string[] | undefined;
+                    promo?: {
+                        message: string;
+                        ends_at?: string | undefined;
+                    } | undefined;
+                    size_guide?: {
+                        title: string;
+                        columns?: string[] | undefined;
+                        rows?: string[][] | undefined;
+                        notes?: string[] | undefined;
+                    } | undefined;
+                }[];
+            } | {
+                kind: "lifestyle_text";
+                text: string;
+                align?: "center" | "left" | undefined;
+            } | {
+                kind: "featured";
+                product: {
+                    sku: string;
+                    title: string;
+                    category: string;
+                    price: {
+                        amount: number;
+                        currency: string;
+                    };
+                    media: string[];
+                    variants: {
+                        sku: string;
+                        attributes: Record<string, string>;
+                        in_stock: boolean;
+                        image?: string | undefined;
+                        available?: number | undefined;
+                    }[];
+                    compare_at?: {
+                        amount: number;
+                        currency: string;
+                    } | undefined;
+                    description?: string | undefined;
+                    badges?: string[] | undefined;
+                    promo?: {
+                        message: string;
+                        ends_at?: string | undefined;
+                    } | undefined;
+                    size_guide?: {
+                        title: string;
+                        columns?: string[] | undefined;
+                        rows?: string[][] | undefined;
+                        notes?: string[] | undefined;
+                    } | undefined;
+                };
+            } | {
+                kind: "lifestyle_image";
+                images: string[];
+            } | {
+                title: string;
+                kind: "grid";
+                products: {
+                    sku: string;
+                    title: string;
+                    category: string;
+                    price: {
+                        amount: number;
+                        currency: string;
+                    };
+                    media: string[];
+                    variants: {
+                        sku: string;
+                        attributes: Record<string, string>;
+                        in_stock: boolean;
+                        image?: string | undefined;
+                        available?: number | undefined;
+                    }[];
+                    compare_at?: {
+                        amount: number;
+                        currency: string;
+                    } | undefined;
+                    description?: string | undefined;
+                    badges?: string[] | undefined;
+                    promo?: {
+                        message: string;
+                        ends_at?: string | undefined;
+                    } | undefined;
+                    size_guide?: {
+                        title: string;
+                        columns?: string[] | undefined;
+                        rows?: string[][] | undefined;
+                        notes?: string[] | undefined;
+                    } | undefined;
+                }[];
+            } | {
+                kind: "review";
+                quotes: {
+                    quote: string;
+                    author: string;
+                }[];
+            } | {
+                kind: "why_us";
+                items: {
+                    title: string;
+                    body: string;
+                    icon?: "payment" | "delivery" | "returns" | undefined;
+                }[];
+            } | {
+                title: string;
+                kind: "explore";
+                links: {
+                    code: string;
+                    label: string;
+                }[];
+            })[];
+        }>;
+    };
+    inventory: {
+        get: (sku: string) => Promise<{
+            sku: string;
+            in_stock: boolean;
+            available: number;
+        }>;
+    };
+    cart: {
+        create: () => Promise<{
+            currency: string;
+            items: {
+                sku: string;
+                qty: number;
+                unit_price: {
+                    amount: number;
+                    currency: string;
+                };
+                line_total: {
+                    amount: number;
+                    currency: string;
+                };
+                attributes?: Record<string, string> | undefined;
+                image?: string | undefined;
+                available?: number | undefined;
+                title?: string | undefined;
+            }[];
+            cart_id: string;
+            totals: {
+                subtotal: {
+                    amount: number;
+                    currency: string;
+                };
+                shipping: {
+                    amount: number;
+                    currency: string;
+                };
+                tax: {
+                    amount: number;
+                    currency: string;
+                };
+                total: {
+                    amount: number;
+                    currency: string;
+                };
+            };
+            locked?: {
+                since: string;
+                reason: "checkout_handoff";
+                expires_at?: string | undefined;
+            } | undefined;
+        }>;
+        get: () => Promise<{
+            currency: string;
+            items: {
+                sku: string;
+                qty: number;
+                unit_price: {
+                    amount: number;
+                    currency: string;
+                };
+                line_total: {
+                    amount: number;
+                    currency: string;
+                };
+                attributes?: Record<string, string> | undefined;
+                image?: string | undefined;
+                available?: number | undefined;
+                title?: string | undefined;
+            }[];
+            cart_id: string;
+            totals: {
+                subtotal: {
+                    amount: number;
+                    currency: string;
+                };
+                shipping: {
+                    amount: number;
+                    currency: string;
+                };
+                tax: {
+                    amount: number;
+                    currency: string;
+                };
+                total: {
+                    amount: number;
+                    currency: string;
+                };
+            };
+            locked?: {
+                since: string;
+                reason: "checkout_handoff";
+                expires_at?: string | undefined;
+            } | undefined;
+        }>;
+        addItem: (body: AddCartItemRequest) => Promise<{
+            currency: string;
+            items: {
+                sku: string;
+                qty: number;
+                unit_price: {
+                    amount: number;
+                    currency: string;
+                };
+                line_total: {
+                    amount: number;
+                    currency: string;
+                };
+                attributes?: Record<string, string> | undefined;
+                image?: string | undefined;
+                available?: number | undefined;
+                title?: string | undefined;
+            }[];
+            cart_id: string;
+            totals: {
+                subtotal: {
+                    amount: number;
+                    currency: string;
+                };
+                shipping: {
+                    amount: number;
+                    currency: string;
+                };
+                tax: {
+                    amount: number;
+                    currency: string;
+                };
+                total: {
+                    amount: number;
+                    currency: string;
+                };
+            };
+            locked?: {
+                since: string;
+                reason: "checkout_handoff";
+                expires_at?: string | undefined;
+            } | undefined;
+        }>;
+        updateItem: (sku: string, body: UpdateCartItemRequest) => Promise<{
+            currency: string;
+            items: {
+                sku: string;
+                qty: number;
+                unit_price: {
+                    amount: number;
+                    currency: string;
+                };
+                line_total: {
+                    amount: number;
+                    currency: string;
+                };
+                attributes?: Record<string, string> | undefined;
+                image?: string | undefined;
+                available?: number | undefined;
+                title?: string | undefined;
+            }[];
+            cart_id: string;
+            totals: {
+                subtotal: {
+                    amount: number;
+                    currency: string;
+                };
+                shipping: {
+                    amount: number;
+                    currency: string;
+                };
+                tax: {
+                    amount: number;
+                    currency: string;
+                };
+                total: {
+                    amount: number;
+                    currency: string;
+                };
+            };
+            locked?: {
+                since: string;
+                reason: "checkout_handoff";
+                expires_at?: string | undefined;
+            } | undefined;
+        }>;
+        removeItem: (sku: string) => Promise<{
+            currency: string;
+            items: {
+                sku: string;
+                qty: number;
+                unit_price: {
+                    amount: number;
+                    currency: string;
+                };
+                line_total: {
+                    amount: number;
+                    currency: string;
+                };
+                attributes?: Record<string, string> | undefined;
+                image?: string | undefined;
+                available?: number | undefined;
+                title?: string | undefined;
+            }[];
+            cart_id: string;
+            totals: {
+                subtotal: {
+                    amount: number;
+                    currency: string;
+                };
+                shipping: {
+                    amount: number;
+                    currency: string;
+                };
+                tax: {
+                    amount: number;
+                    currency: string;
+                };
+                total: {
+                    amount: number;
+                    currency: string;
+                };
+            };
+            locked?: {
+                since: string;
+                reason: "checkout_handoff";
+                expires_at?: string | undefined;
+            } | undefined;
+        }>;
+        /**
+         * Hand the cart to DAZN checkout and get the URL to send the fan to.
+         *
+         * The URL is opaque — redirect to it, never parse it. This is the last call in our
+         * journey; payment, order and confirmation all happen on DAZN.
+         */
+        handoff: () => Promise<{
+            checkout_url: string;
+        }>;
+    };
+    auth: {
+        /** Exchange a single-use DAZN identity JWT for a session (sets the cookie). */
+        exchangeSession: (body: SessionExchangeRequest) => Promise<{
+            user_id: string;
+        }>;
+        /**
+         * Redeem the `session` + `code` a DAZN redirect arrives with (sets the cookie).
+         * The entry path from the DAZN app; see `ShopSessionRequest`.
+         */
+        redeemShopSession: (body: ShopSessionRequest) => Promise<{
+            expires_at: number;
+            shop_session_id: string;
+            session_token: string;
+            email?: string | undefined;
+            product?: {
+                title: string;
+                id: string;
+                vendor_id: string;
+            } | null | undefined;
+        }>;
+    };
+};
+
+/**
+ * The session seam, implemented once at the transport level.
+ *
+ * Retry-on-401 lives here rather than wrapped around each API method for a reason: the
+ * typed client is a nested object of namespaces, so wrapping the surface means a proxy
+ * or ~20 hand-written wrappers, and either would drift the first time a method is added.
+ * A `fetch` is one function and every request already passes through it.
+ *
+ * **The retry budget is exactly one.** A host whose `getToken` cannot recover — expired
+ * refresh, revoked session, signed-out user — would otherwise have every request spin
+ * against its identity service. One retry, then we stop and say so.
+ */
+export declare function createShopFetch(opts: {
+    getToken: GetToken;
+    onEvent?: OnEvent;
+    fetchImpl?: typeof fetch;
+    /** Needed only to detect the silent-anonymous-session trap below. */
+    sessionTransport?: 'bearer' | 'cookie';
+}): typeof fetch;
+
+/** Thrown on any non-2xx `/v1` response, carrying the standard error object. */
+declare class DaznApiError extends Error {
+    readonly status: number;
+    readonly code?: ErrorCode_2;
+    readonly requestId?: string;
+    readonly body?: ApiErrorBody;
+    constructor(status: number, parsed?: {
+        error: ApiErrorBody;
+        request_id: string;
+    });
+}
+
+declare type DaznClient = ReturnType<typeof createClient>;
+
+export declare interface DaznShopConfig {
+    apiBaseUrl: string;
+    getToken: GetToken;
+    /**
+     * How the session travels to the commerce API. Default `'bearer'`.
+     *
+     * - `'bearer'` — the token from {@link GetToken} goes in `Authorization`, and cookies
+     *   are **not** sent. Correct when mounted in a host's page: the SDK is cross-origin
+     *   with the API, holds no credential of its own, and a cookie would be neither sent
+     *   nor wanted.
+     * - `'cookie'` — the engine's httpOnly session cookie is sent instead. Correct for a
+     *   first-party web view that authenticates by cookie and has no token for JS to hold.
+     *
+     * Getting this wrong does not fail loudly. Requests simply arrive unauthenticated, and
+     * an environment that issues anonymous sessions will hand out a **new** one per call —
+     * so an item is added to one cart and read back from another, and the basket looks
+     * empty rather than broken. That is exactly how this was found.
+     */
+    sessionTransport?: 'bearer' | 'cookie';
+    /**
+     * Origin (or path prefix) the SDK's own static assets are served from — the design
+     * imagery the shop-entry screen renders. Default: none, i.e. paths are left as written.
+     *
+     * These are **root-relative** in the source (`/figma/home/hero.jpg`), which is correct
+     * in our own app and wrong everywhere else: a browser resolves them against the page's
+     * origin, and mounted in a host's page that is the **host's** origin. The host does not
+     * serve our imagery, so every one of them 404s and the entry screen renders with broken
+     * images while the rest of the SDK works perfectly — which is exactly how it presents.
+     *
+     * Only root-relative paths are rebased. Absolute and protocol-relative URLs are left
+     * untouched, because catalogue media arrives from the API already absolute and must not
+     * be rewritten.
+     */
+    assetBaseUrl?: string;
+    market?: Market;
+    navigate?: Navigate;
+    /**
+     * @deprecated No longer affects how anything renders, and safe to remove.
+     *
+     * The storefront has one design per screen, not two: the shop entry and category pages
+     * are drawn dark, the PDP and cart light. There is no light version of the dark hero to
+     * switch to, so this never selected between two designs — it repainted the tokens under
+     * a screen built for the other palette, which is how `theme="light"` produced near-black
+     * button text on a dark photograph.
+     *
+     * Still accepted so that passing it does not break a build, and still readable from
+     * context by a host that wants to know what was asked for. It decides nothing.
+     */
+    theme?: 'light' | 'dark' | 'auto';
+    notifications?: 'internal' | 'host';
+    onEvent?: OnEvent;
+    locale?: string;
+}
+
+/**
+ * Mount once, high in the host tree. Owns configuration, the API client, the session
+ * seam and event fan-out, so two components rendering the same cart cannot disagree.
+ *
+ * Nesting providers is supported but each gets an independent client — don't, unless
+ * that is what you mean.
+ */
+export declare function DaznShopProvider({ children, ...config }: DaznShopConfig & {
+    children: ReactNode;
+}): JSX.Element;
+
+/** A row this surface cannot put a number against yet. */
+export declare type DeferredLine = 'shipping' | 'tax';
+
+/**
+ * A whole-number discount percentage derived from two server-provided Money values.
+ * This is presentational rounding of values the server already computed — it does NOT
+ * price anything. Returns undefined when there is no genuine discount.
+ */
+export declare function discountPct(price: Money, compareAt?: Money): number | undefined;
+
+/** Distinct values for an attribute key, in first-seen order. */
+export declare function distinctValues(variants: ProductVariant[], key: string): string[];
+
+/** Neutral empty state with a title, optional body, and optional action. */
+export declare function EmptyState({ title, body, action, icon }: EmptyStateProps): JSX.Element;
+
+export declare interface EmptyStateProps {
+    title: string;
+    body?: string;
+    /** Optional call-to-action (e.g. a Button or Link). */
+    action?: ReactNode;
+    icon?: ReactNode;
+}
+
+/**
+ * The stable error `code` enum. Clients branch on `code`, never on `message`.
+ * Additive-only: a new code is a minor bump consumers must tolerate.
+ *
+ * | code               | HTTP | when                                          |
+ * | ------------------ | ---- | --------------------------------------------- |
+ * | invalid_request    | 400  | malformed body or missing field               |
+ * | unauthorized       | 401  | missing/invalid session or credentials        |
+ * | out_of_stock       | 409  | requested qty exceeds available stock         |
+ * | cart_locked        | 409  | cart handed to checkout; mutations refused    |
+ * | sku_not_found      | 404  | a referenced SKU/product does not exist       |
+ * | category_not_found | 404  | a referenced category code does not exist     |
+ * | amount_mismatch    | 422  | totals do not match the authorised amount     |
+ * | duplicate_order    | 200  | idempotent replay — existing order returned   |
+ * | forbidden          | 403  | authenticated, but the role may not do this   |
+ * | invalid_transition | 409  | fulfilment move not allowed from this status  |
+ * | rate_limited       | 429  | too many requests                             |
+ * | server_error       | 500  | unexpected error (safe to retry idempotent)   |
+ */
+declare const ErrorCode: z.ZodEnum<["invalid_request", "unauthorized", "out_of_stock", "cart_locked", "sku_not_found", "category_not_found", "amount_mismatch", "duplicate_order", "order_not_found", "order_not_cancellable", "forbidden", "invalid_transition", "rate_limited", "server_error"]>;
+
+declare type ErrorCode = z.infer<typeof ErrorCode>;
+
+/**
+ * The stable error `code` enum. Clients branch on `code`, never on `message`.
+ * Additive-only: a new code is a minor bump consumers must tolerate.
+ *
+ * | code               | HTTP | when                                          |
+ * | ------------------ | ---- | --------------------------------------------- |
+ * | invalid_request    | 400  | malformed body or missing field               |
+ * | unauthorized       | 401  | missing/invalid session or credentials        |
+ * | out_of_stock       | 409  | requested qty exceeds available stock         |
+ * | cart_locked        | 409  | cart handed to checkout; mutations refused    |
+ * | sku_not_found      | 404  | a referenced SKU/product does not exist       |
+ * | category_not_found | 404  | a referenced category code does not exist     |
+ * | amount_mismatch    | 422  | totals do not match the authorised amount     |
+ * | duplicate_order    | 200  | idempotent replay — existing order returned   |
+ * | forbidden          | 403  | authenticated, but the role may not do this   |
+ * | invalid_transition | 409  | fulfilment move not allowed from this status  |
+ * | rate_limited       | 429  | too many requests                             |
+ * | server_error       | 500  | unexpected error (safe to retry idempotent)   |
+ */
+declare const ErrorCode_2: z.ZodEnum<["invalid_request", "unauthorized", "out_of_stock", "cart_locked", "sku_not_found", "category_not_found", "amount_mismatch", "duplicate_order", "order_not_found", "order_not_cancellable", "forbidden", "invalid_transition", "rate_limited", "server_error"]>;
+
+declare type ErrorCode_2 = z.infer<typeof ErrorCode_2>;
+
+/**
+ * Error state whose copy is derived from the API error `code`. The retry affordance is
+ * shown only for retriable codes (or when the caller forces `onRetry`).
+ */
+export declare function ErrorState({ code, title, body, onRetry, retryLabel }: ErrorStateProps): JSX.Element;
+
+export declare interface ErrorStateProps {
+    /** API error code — copy is mapped from this, never from a raw message. */
+    code?: ErrorCode;
+    /** Override the mapped title/body if a screen needs bespoke copy. */
+    title?: string;
+    body?: string;
+    /** Retry handler; only rendered when the error is retriable. */
+    onRetry?: () => void;
+    retryLabel?: string;
+}
+
+/**
+ * UI treatment for each API error `code`. The storefront ALWAYS branches on the
+ * machine `code` (never the human message). Copy is display-only; the engine remains
+ * authoritative for what actually happened.
+ */
+export declare interface ErrorTreatment {
+    title: string;
+    body: string;
+    /** May the user safely retry the same action? */
+    retriable: boolean;
+    /** Should this trigger the silent DAZN re-handshake instead of a visible error? */
+    reauth?: boolean;
+}
+
+declare interface ExploreLink {
+    label: string;
+    code: string;
+}
+
+/** "Shop more" — links to sibling categories. */
+export declare function ExploreList({ title, links }: {
+    title: string;
+    links: ExploreLink[];
+}): JSX.Element;
+
+/** Horizontal chip filter bar for the PLP. Chips are toggle buttons. */
+export declare function FilterBar({ options, active, onToggle, onClear }: FilterBarProps): JSX.Element;
+
+export declare interface FilterBarProps {
+    options: FilterOption[];
+    /** Currently active filter values. */
+    active: string[];
+    onToggle: (value: string) => void;
+    onClear?: () => void;
+}
+
+export declare interface FilterOption {
+    value: string;
+    label: string;
+}
+
+/**
+ * Format a {@link Money} for display in the given locale. Divides minor units by the
+ * currency exponent purely for presentation.
+ */
+export declare function formatMoney(money: Money, locale?: string): string;
+
+/**
+ * Supplies the session bearer token. Called before each authenticated request and again,
+ * once, after a `401`.
+ *
+ * Returning `undefined` or an empty string is legal and means "no session yet":
+ * catalogue browsing works without one, and cart operations raise `session_required`.
+ * The SDK never persists what this returns and never holds a refresh credential — that
+ * stays with the host, which is the whole point of it being a callback.
+ */
+export declare type GetToken = () => string | undefined | Promise<string | undefined>;
+
+declare function HomeShowcase(): JSX.Element;
+export { HomeShowcase }
+export { HomeShowcase as ShopHome }
+
+/**
+ * 4.5 Identity gate. **DAZN owns identity; the storefront runs no login**, so this asks
+ * the host to take over rather than doing anything itself.
+ *
+ * In the app this called a `window.DAZNBridge` method. That was right for a web view and
+ * wrong for a mounted component: reaching for a global the host may not have installed
+ * is a hidden coupling, and a component that silently does nothing when the global is
+ * absent is worse than one that says so. It now raises `session_required` — the same
+ * request, made through the contract the host already handles.
+ *
+ * The cart is session-scoped server-side and survives the round trip; we never drop it.
+ */
+export declare function IdentityGate({ returnTo }: IdentityGateProps): JSX.Element;
+
+export declare interface IdentityGateProps {
+    /** Where the host should return the fan after its sign-in flow. */
+    returnTo: string;
+}
+
+/**
+ * `GET /v1/inventory/{sku}` — read-model availability. Authoritative stock is Odoo;
+ * a live check is also run at checkout.
+ */
+declare const Inventory: z.ZodObject<{
+    sku: z.ZodString;
+    available: z.ZodNumber;
+    in_stock: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    sku: string;
+    available: number;
+    in_stock: boolean;
+}, {
+    sku: string;
+    available: number;
+    in_stock: boolean;
+}>;
+
+declare type Inventory = z.infer<typeof Inventory>;
+
+/** A duplicate order (200 replay) is a SUCCESS, never an error to surface. */
+export declare function isDuplicateOrder(err: unknown): boolean;
+
+/** A 401 anywhere in the flow means the session lapsed — re-handshake, keep the cart. */
+export declare function isUnauthorized(err: unknown): boolean;
+
+/** Full-width lifestyle image (rounded), inset from the page edges. */
+export declare function LifestyleImage({ images }: {
+    images: string[];
+}): JSX.Element | null;
+
+/** Editorial text band between PCP sections. */
+export declare function LifestyleText({ text, align }: LifestyleTextProps): JSX.Element;
+
+export declare interface LifestyleTextProps {
+    text: string;
+    align?: 'center' | 'left';
+}
+
+/**
+ * Query params for the product list. Extends {@link MarketQuery}, so `country` and
+ * `lang` are accepted here as on every other catalogue read.
+ */
+declare const ListProductsQuery: z.ZodObject<{
+    country: z.ZodOptional<z.ZodString>;
+    lang: z.ZodOptional<z.ZodString>;
+} & {
+    category: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    country?: string | undefined;
+    lang?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    category?: string | undefined;
+}, {
+    country?: string | undefined;
+    lang?: string | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    category?: string | undefined;
+}>;
+
+declare type ListProductsQuery = z.infer<typeof ListProductsQuery>;
+
+export declare interface Market {
+    /** ISO 3166-1 alpha-2. Selects pricing, currency and merchandising. */
+    country: string;
+    /** IETF language tag. Display copy only — deliberately independent of `country`. */
+    lang: string;
+}
+
+/**
+ * Swipeable image gallery with dot indicators. Reduced-motion aware (smooth-scroll is
+ * disabled globally under prefers-reduced-motion). Keyboard: dots are real buttons.
+ */
+export declare function MediaGallery({ media, alt }: MediaGalleryProps): JSX.Element;
+
+export declare interface MediaGalleryProps {
+    media: string[];
+    alt: string;
+}
+
+export declare function minorUnitExponent(currency: string): number;
+
+/**
+ * Money is **always** integer minor units + an ISO-4217 currency.
+ * `{ amount: 2500, currency: 'GBP' }` = £25.00. Never a float, never a bare number.
+ *
+ * Strict: the shape is fixed, so unknown keys are rejected everywhere Money appears.
+ */
+declare const Money: z.ZodObject<{
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    amount: number;
+    currency: string;
+}, {
+    amount: number;
+    currency: string;
+}>;
+
+declare type Money = z.infer<typeof Money>;
+
+/** Host router adapter. Omit it and navigable elements only raise `navigate` events. */
+export declare type Navigate = (to: ShopRoute) => void;
+
+/**
+ * Events are informational. **No event is a control point** — a handler cannot cancel
+ * one, and the SDK does not await it. Gate an action in host UI before mounting the
+ * component instead.
+ */
+export declare type OnEvent = (event: ShopEvent) => void;
+
+/**
+ * Fulfilment order status. Lives here (not in a synchronous order contract) because the
+ * engine no longer owns orders (ADR-0008) — order/fulfilment status reaches us only as
+ * async events (Odoo → engine → consumers). DAZN is authoritative for completed orders.
+ */
+declare const OrderStatus: z.ZodEnum<["confirmed", "packed", "shipped", "delivered", "cancelled", "refunded"]>;
+
+declare type OrderStatus = z.infer<typeof OrderStatus>;
+
+/**
+ * The pricing breakdown. DISPLAY ONLY — every value is server-authoritative; the UI
+ * never sums or computes anything here.
+ */
+export declare function OrderSummary({ pricing, deferred }: OrderSummaryProps): JSX.Element;
+
+export declare interface OrderSummaryProps {
+    pricing: Pricing;
+    /**
+     * Rows whose value is **not ours to state**, rendered as "Calculated at checkout"
+     * instead of the figure in `pricing`.
+     *
+     * This exists because a zero is ambiguous and the ambiguity is dangerous. `Pricing`
+     * requires all four values, so the engine sends `0` for shipping and tax it has not
+     * computed — and rendering that gives the fan a confident "Tax £0.00" and a total that
+     * changes at checkout. DAZN owns checkout and therefore owns delivery and tax
+     * (ADR-0008), so in the cart both are genuinely unknown rather than genuinely free.
+     *
+     * When anything is deferred the grand total is withheld too: a total that omits
+     * delivery is not a total. Subtotal carries the emphasis instead.
+     */
+    deferred?: DeferredLine[];
+}
+
+/** PCP hero — category title + subtitle over a full-bleed lifestyle image (dark). */
+export declare function PcpHero({ hero }: {
+    hero: CategoryHero;
+}): JSX.Element;
+
+/**
+ * Row of merchandising badges shown above the PDP title (mobile/badge/top-pick — light
+ * surface, dark text). Renders nothing when the catalogue provides no flags, so the
+ * layout collapses cleanly rather than showing an empty row.
+ */
+export declare function PdpBadges({ badges }: PdpBadgesProps): JSX.Element | null;
+
+export declare interface PdpBadgesProps {
+    /** Merchandising flags (Product.badges), e.g. ["Top pick", "99% Happy Customers"]. */
+    badges: string[];
+}
+
+/**
+ * Displays a price with an optional discount. DISPLAY ONLY — it never computes totals;
+ * any percentage shown is a presentational rounding of values the server already
+ * provided. Matches the DAZN design: discounts render as the green sale badge (PDP) or a
+ * struck-through was-price (cards) — never as red discount text.
+ */
+export declare function PriceBlock({ price, compareAt, discountPct, size, variant, align, }: PriceBlockProps): JSX.Element;
+
+export declare interface PriceBlockProps {
+    /** Current server-authoritative price. */
+    price: Money;
+    /** Optional strike-through "was" price (server-provided). */
+    compareAt?: Money;
+    /** Optional explicit discount %. If omitted, derived from price/compareAt. */
+    discountPct?: number;
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * How a discount is shown:
+     * - `strikethrough` (default, product cards): current price + struck was-price.
+     * - `badge` (PDP): current price + struck was-price + a green `-NN%` sale badge.
+     */
+    variant?: 'strikethrough' | 'badge';
+    /** Cross-axis alignment: `baseline` (default), `center`, or `end` (cards). */
+    align?: 'baseline' | 'center' | 'end';
+}
+
+/**
+ * The four-line pricing breakdown shared by the cart (`totals`) and the fan-facing
+ * order (`pricing`). Every line is Money in the same currency.
+ */
+declare const Pricing: z.ZodObject<{
+    subtotal: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+    shipping: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+    tax: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+    total: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    subtotal: {
+        amount: number;
+        currency: string;
+    };
+    shipping: {
+        amount: number;
+        currency: string;
+    };
+    tax: {
+        amount: number;
+        currency: string;
+    };
+    total: {
+        amount: number;
+        currency: string;
+    };
+}, {
+    subtotal: {
+        amount: number;
+        currency: string;
+    };
+    shipping: {
+        amount: number;
+        currency: string;
+    };
+    tax: {
+        amount: number;
+        currency: string;
+    };
+    total: {
+        amount: number;
+        currency: string;
+    };
+}>;
+
+declare type Pricing = z.infer<typeof Pricing>;
+
+/** A catalog product, served from the engine's cached read model (synced from Odoo). */
+declare const Product: z.ZodObject<{
+    sku: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodString;
+    price: z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>;
+    /**
+     * Optional strike-through "was" price for a sale. Additive/optional: the engine only
+     * populates it once the pricing source is agreed (A2 — pricing contract). Display
+     * only; never authoritative. Absent = not on sale.
+     */
+    compare_at: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        amount: number;
+        currency: string;
+    }, {
+        amount: number;
+        currency: string;
+    }>>;
+    media: z.ZodArray<z.ZodString, "many">;
+    variants: z.ZodArray<z.ZodObject<{
+        sku: z.ZodString;
+        attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+        in_stock: z.ZodBoolean;
+        /**
+         * Optional per-variant image — e.g. the colour swatch/tile shown in the PDP colour
+         * selector. Absent = fall back to the product's `media`.
+         */
+        image: z.ZodOptional<z.ZodString>;
+        /**
+         * Optional per-variant stock count, used to show "N left" low-stock badges. Display
+         * only — the authoritative check runs at checkout. Absent = show no count.
+         */
+        available: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        sku: string;
+        attributes: Record<string, string>;
+        in_stock: boolean;
+        image?: string | undefined;
+        available?: number | undefined;
+    }, {
+        sku: string;
+        attributes: Record<string, string>;
+        in_stock: boolean;
+        image?: string | undefined;
+        available?: number | undefined;
+    }>, "many">;
+    /** Optional long-form product description (PDP details accordion). Absent = no body. */
+    description: z.ZodOptional<z.ZodString>;
+    /**
+     * Optional merchandising flags shown as badges on the PDP/cards (e.g. "Top pick").
+     * Free-form labels sourced from the catalogue; absent/empty = no badges.
+     */
+    badges: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Optional PDP promo nudge (display only — the offer is applied at DAZN checkout). */
+    promo: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        /** ISO-8601 end time that drives the countdown; absent = show the message, no timer. */
+        ends_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        ends_at?: string | undefined;
+    }, {
+        message: string;
+        ends_at?: string | undefined;
+    }>>;
+    /**
+     * Optional category-wide sizing help for the PDP "Size guide" overlay. Absent = the
+     * storefront hides the control rather than opening an empty overlay.
+     */
+    size_guide: z.ZodOptional<z.ZodObject<{
+        title: z.ZodString;
+        /** Column headings for `rows`, e.g. `['Size', 'Chest (cm)', 'Length (cm)']`. */
+        columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** One row per size; each row's length matches `columns`. */
+        rows: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+        /** Free-text fit guidance, e.g. "Relaxed, slightly oversized fit". */
+        notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        columns?: string[] | undefined;
+        rows?: string[][] | undefined;
+        notes?: string[] | undefined;
+    }, {
+        title: string;
+        columns?: string[] | undefined;
+        rows?: string[][] | undefined;
+        notes?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sku: string;
+    title: string;
+    category: string;
+    price: {
+        amount: number;
+        currency: string;
+    };
+    media: string[];
+    variants: {
+        sku: string;
+        attributes: Record<string, string>;
+        in_stock: boolean;
+        image?: string | undefined;
+        available?: number | undefined;
+    }[];
+    compare_at?: {
+        amount: number;
+        currency: string;
+    } | undefined;
+    description?: string | undefined;
+    badges?: string[] | undefined;
+    promo?: {
+        message: string;
+        ends_at?: string | undefined;
+    } | undefined;
+    size_guide?: {
+        title: string;
+        columns?: string[] | undefined;
+        rows?: string[][] | undefined;
+        notes?: string[] | undefined;
+    } | undefined;
+}, {
+    sku: string;
+    title: string;
+    category: string;
+    price: {
+        amount: number;
+        currency: string;
+    };
+    media: string[];
+    variants: {
+        sku: string;
+        attributes: Record<string, string>;
+        in_stock: boolean;
+        image?: string | undefined;
+        available?: number | undefined;
+    }[];
+    compare_at?: {
+        amount: number;
+        currency: string;
+    } | undefined;
+    description?: string | undefined;
+    badges?: string[] | undefined;
+    promo?: {
+        message: string;
+        ends_at?: string | undefined;
+    } | undefined;
+    size_guide?: {
+        title: string;
+        columns?: string[] | undefined;
+        rows?: string[][] | undefined;
+        notes?: string[] | undefined;
+    } | undefined;
+}>;
+
+declare type Product = z.infer<typeof Product>;
+
+/**
+ * 4.3 PDP interactive surface, aligned to the DAZN mobile PDP design. Sections render
+ * from server-authoritative contract data: badges, title + price, promo nudge, description
+ * accordion, size + colour selectors, and static shipping/returns. Size and colour are
+ * independent dimensions; the SKU is resolved from both. A required selection must be made
+ * before add-to-cart — tapping without one scrolls to the first missing selector (and flips
+ * the size error). Add-to-cart calls the engine through the session so a 401 silently
+ * re-handshakes.
+ */
+export declare function ProductDetail({ product, inventory, recommendations }: ProductDetailProps): JSX.Element;
+
+export declare interface ProductDetailProps {
+    product: Product;
+    inventory: Inventory | null;
+    /** "You may like it" rail — related products from the engine. Empty = rail hidden. */
+    recommendations?: Product[];
+}
+
+/**
+ * PDP "Product details" accordion (mobile/pdp/details). Collapsed clamps the body to
+ * three lines with a more/less toggle. Only renders when the catalogue provides a
+ * description — no placeholder copy is invented.
+ */
+export declare function ProductDetails({ description }: ProductDetailsProps): JSX.Element | null;
+
+export declare interface ProductDetailsProps {
+    /** Long-form description (Product.description). The block is not rendered when empty. */
+    description: string;
+}
+
+/**
+ * PLP grid with cursor-based infinite scroll and a chip FilterBar.
+ *
+ * `initialProducts` is the host's first page — server-rendered where the host can, or
+ * simply fetched before mount. Subsequent pages come from the provider's client, so the
+ * grid inherits the host's session and market without being told about either.
+ *
+ * Filtering is a client-side view over what has loaded; it deliberately does not refetch,
+ * because a filter that resets an infinite scroll loses the fan's place.
+ */
+export declare function ProductGrid({ category, initialProducts, initialCursor, filters, }: ProductGridProps): JSX.Element;
+
+export declare interface ProductGridProps {
+    category: string;
+    initialProducts: Product[];
+    initialCursor: string | null;
+    filters?: FilterOption[];
+}
+
+/**
+ * Optional PDP promo nudge (Figma `mobile/pdp/promo`). DISPLAY ONLY — the `message` and
+ * the `ends_at` countdown are presentational; the actual offer is applied by DAZN at
+ * checkout. The storefront never computes a discount from this.
+ */
+declare const ProductPromo: z.ZodObject<{
+    message: z.ZodString;
+    /** ISO-8601 end time that drives the countdown; absent = show the message, no timer. */
+    ends_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    ends_at?: string | undefined;
+}, {
+    message: string;
+    ends_at?: string | undefined;
+}>;
+
+declare type ProductPromo = z.infer<typeof ProductPromo>;
+
+/**
+ * Product card (Figma `mobile/product-card`) — the shared rail/grid card. Media is a
+ * 165:220 image (radius-6) with a TOP PICK flag top-left and a green sale badge
+ * bottom-left; below sit the title (2-line clamp) and price with a struck was-price.
+ */
+export declare function ProductTile({ product, priority }: ProductTileProps): JSX.Element;
+
+export declare interface ProductTileProps {
+    product: Product;
+    /** Priority-load the image (above-the-fold tiles). */
+    priority?: boolean;
+}
+
+/** `GET /v1/catalog/products` — a single purchasable variant of a product. */
+declare const ProductVariant: z.ZodObject<{
+    sku: z.ZodString;
+    attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    in_stock: z.ZodBoolean;
+    /**
+     * Optional per-variant image — e.g. the colour swatch/tile shown in the PDP colour
+     * selector. Absent = fall back to the product's `media`.
+     */
+    image: z.ZodOptional<z.ZodString>;
+    /**
+     * Optional per-variant stock count, used to show "N left" low-stock badges. Display
+     * only — the authoritative check runs at checkout. Absent = show no count.
+     */
+    available: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sku: string;
+    attributes: Record<string, string>;
+    in_stock: boolean;
+    image?: string | undefined;
+    available?: number | undefined;
+}, {
+    sku: string;
+    attributes: Record<string, string>;
+    in_stock: boolean;
+    image?: string | undefined;
+    available?: number | undefined;
+}>;
+
+declare type ProductVariant = z.infer<typeof ProductVariant>;
+
+/**
+ * A whole product-detail screen, data fetching included — a **level 1 view**.
+ *
+ * Fetches the product, then enriches it with inventory and recommendations. Those two are
+ * deliberately best-effort: the PDP renders perfectly well without either, so a failure in
+ * one must not fault the screen. `Promise.allSettled` rather than `all` is what makes that
+ * true — with `all`, a recommendations outage would blank a page the fan could otherwise
+ * have bought from.
+ *
+ * `sku_not_found` is separated from the generic error path because it is not a fault: the
+ * product is gone, and "this is no longer available" is the honest thing to say. An error
+ * card inviting a retry would be a lie.
+ */
+export declare function ProductView({ sku, initialData, showRecommendations, onNotFound, }: ProductViewProps): JSX.Element;
+
+export declare interface ProductViewProps {
+    /** The product's SKU. */
+    sku: string;
+    /**
+     * An already-fetched product, from a host that server-rendered this screen. Painted on
+     * the first frame and revalidated in the background.
+     *
+     * `inventory` is optional even here: it is the one field guaranteed to be stale by the
+     * time a server-rendered page is interactive, so a host is not obliged to have fetched
+     * it, and the revalidation replaces it either way.
+     */
+    initialData?: {
+        product: Product;
+        inventory?: Inventory | null;
+    };
+    /** The "you may like it" rail. Default `true`. */
+    showRecommendations?: boolean;
+    /**
+     * Replaces the built-in empty state when the SKU does not exist. Only for
+     * `sku_not_found` — a genuine fault still renders the recoverable error state.
+     */
+    onNotFound?: () => ReactNode;
+}
+
+/**
+ * PDP promo banner (Figma `mobile/pdp/promo`). DISPLAY ONLY — the message and countdown
+ * are a merchandising nudge; the actual offer is applied by DAZN at checkout. The timer
+ * is mounted client-side (starts null to match SSR, so there is no hydration mismatch)
+ * and hides itself once elapsed or when the promo has no `ends_at`.
+ */
+export declare function PromoBanner({ promo }: {
+    promo: ProductPromo;
+}): JSX.Element;
+
+/**
+ * Quantity stepper. At qty=1 the decrement turns into a delete affordance; the
+ * increment is capped at max stock. Values are never used to compute money.
+ *
+ * When the cap is reached the reason is stated inline rather than the control simply
+ * going dead — a disabled `+` with no explanation reads as a bug, and the fan cannot
+ * tell "we have no more" from "this is broken".
+ */
+export declare function QtyStepper({ qty, max, onChange, onRemove, disabled }: QtyStepperProps): JSX.Element;
+
+export declare interface QtyStepperProps {
+    qty: number;
+    /** Max selectable quantity (capped at available stock). */
+    max?: number;
+    onChange: (qty: number) => void;
+    /** Called when decrementing from 1 (the decrement becomes a delete). */
+    onRemove?: () => void;
+    disabled?: boolean;
+}
+
+/**
+ * Horizontally scrollable product rail. Renders NOTHING when there are no products
+ * (empty rails are hidden entirely, per spec).
+ */
+export declare function RailCarousel({ title, products, seeAllTo, inset }: RailCarouselProps): JSX.Element | null;
+
+export declare interface RailCarouselProps {
+    title: string;
+    products: Product[];
+    /**
+     * "See all" destination, as a storefront route.
+     *
+     * Was a raw `href` on a plain anchor. In a mounted component that hard-navigates the
+     * HOST's page out from under the fan — the exact thing the navigation seam exists to
+     * prevent — so it now goes through {@link ShopLink} and the host's router.
+     */
+    seeAllTo?: ShopRoute;
+    /**
+     * Inset variant: the rail lives inside an already-padded column (the PDP content
+     * block) rather than bleeding edge-to-edge like the home rails, so it adds no side
+     * padding of its own and uses fixed-width cards.
+     */
+    inset?: boolean;
+}
+
+/**
+ * Resolve an asset path against the host-configured asset base.
+ *
+ * Mounted in DAZN's page, a root-relative `src` resolves against DAZN's origin — so the
+ * SDK's own design imagery is requested from a server that has never heard of it. This
+ * is the one rewrite that fixes it, and it is deliberately narrow.
+ *
+ * Left alone, always:
+ * - **absolute URLs** (`https://…`, `data:`, `blob:`) — catalogue media arrives from the
+ *   API already absolute, and rewriting it would break the images that currently work.
+ * - **protocol-relative** (`//cdn…`) — already origin-bearing.
+ * - **relative** (`./x`, `x.jpg`) — resolves against the document, which is the host's
+ *   business, not ours.
+ *
+ * With no base configured this is the identity function, so our own app — which serves
+ * these paths itself — needs no configuration and keeps working unchanged.
+ */
+export declare function resolveAssetUrl(src: string, base?: string): string;
+
+/**
+ * Resolve the variant SKU for the selected size/colour, considering only the dimensions
+ * the product actually has. Returns null until every present dimension is chosen.
+ */
+export declare function resolveSku(variants: ProductVariant[], size: string | null, colour: string | null): string | null;
+
+declare interface Review {
+    quote: string;
+    author: string;
+}
+
+/** Testimonial carousel — swipeable light cards with dot pagination. */
+export declare function ReviewCarousel({ quotes }: {
+    quotes: Review[];
+}): JSX.Element;
+
+/**
+ * The single green sale/discount badge (Figma `mobile/badge/sale`): success-soft
+ * surface, success text, a discount-tag icon and `-NN%`. One look everywhere — the PDP
+ * price row and the product-card image overlay both use it.
+ */
+export declare function SaleBadge({ pct }: SaleBadgeProps): JSX.Element;
+
+export declare interface SaleBadgeProps {
+    /** Whole-number discount percentage, e.g. 30 → "-30%". */
+    pct: number;
+}
+
+/**
+ * What a whole screen looks like while its data is in flight.
+ *
+ * This replaces `<Skeleton />` on its own, which was not a loading state at all: with no
+ * width, height or content, a `display: block` span computes to **zero pixels tall**. The
+ * views returned it, it painted nothing, and whatever the host had behind us showed
+ * through — which in DAZN's dark app is a black screen between tapping a link and the
+ * product arriving. It looked like a navigation bug and was a CSS one.
+ *
+ * Two things follow from that and are the whole point of this component. It has real
+ * dimensions, so there is something on screen for the entire wait. And it is a
+ * `ShopSurface`, so the wait is painted in the palette of the screen you are waiting for
+ * — a light PDP that resolves out of a light wait, rather than out of the host's black.
+ *
+ * The blocks are laid out roughly where the real content lands, so the screen settles into
+ * place instead of rearranging itself once the data is in.
+ */
+export declare function ScreenSkeleton({ tone, shape }: ScreenSkeletonProps): JSX.Element;
+
+export declare interface ScreenSkeletonProps {
+    /** The palette of the screen being waited for, so the wait is not a different colour. */
+    tone: ShopTone;
+    /** `media` leads with an image block (PDP, category). `list` is rows (cart, search). */
+    shape?: 'media' | 'list';
+}
+
+/** Request: the single-use DAZN identity JWT to exchange. */
+declare const SessionExchangeRequest: z.ZodObject<{
+    token: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    token: string;
+}, {
+    token: string;
+}>;
+
+declare type SessionExchangeRequest = z.infer<typeof SessionExchangeRequest>;
+
+/**
+ * PDP shipping & returns block (mobile/pdp/shipping-info). Static informational copy —
+ * no free-shipping threshold (per design). The shopper picks the delivery tier at
+ * DAZN's checkout; this only signals that the options exist. Returns window is fixed.
+ */
+export declare function ShippingInfo(): JSX.Element;
+
+declare interface ShopContextValue {
+    api: DaznClient;
+    market?: Market;
+    theme: 'light' | 'dark' | 'auto';
+    notifications: 'internal' | 'host';
+    locale?: string;
+    assetBaseUrl?: string;
+    emit: OnEvent;
+    /** Listen to the same event stream the host sees. Returns an unsubscribe. */
+    subscribe: (listener: OnEvent) => () => void;
+    navigate: (to: ShopRoute) => void;
+}
+
+export declare type ShopEvent = {
+    type: 'ready';
+} | {
+    type: 'navigate';
+    to: ShopRoute;
+} | {
+    type: 'product_viewed';
+    sku: string;
+} | {
+    type: 'cart_updated';
+    itemCount: number;
+    subtotal: Money;
+} | {
+    type: 'add_to_cart';
+    sku: string;
+    qty: number;
+} | {
+    type: 'remove_from_cart';
+    sku: string;
+    qty: number;
+} | {
+    type: 'checkout_handoff';
+    cartId: string;
+    url?: string;
+} | {
+    type: 'session_required';
+    action: string;
+} | {
+    type: 'session_expired';
+} | {
+    type: 'notification';
+    tone: 'neutral' | 'success' | 'critical';
+    message: string;
+} | {
+    type: 'error';
+    code: ErrorCode | undefined;
+    scope: string;
+};
+
+/**
+ * The 56px shop header from Figma `mobile/header` (context=shop): back chevron on the
+ * left, cart and overflow on the right.
+ *
+ * **Optional, and off by default in every view.** In the real embed the DAZN app provides
+ * this chrome — it is their back button and their menu — which is why nothing in the SDK
+ * renders it for you. It is exported because DAZN's team asked for it after finding the
+ * bar they see in our own storefront was not available to them: rebuilding it is a waste
+ * if the design is ours, and a mismatch if only half of it is.
+ *
+ * The cart count is real, never fabricated: `useCartCount` returns `null` until it knows,
+ * and the badge stays hidden for both `null` and `0` — an empty cart wearing a "0" is
+ * noise, and a guessed number is worse.
+ *
+ * Mount it inside `DaznShopProvider`, and inside `CartSheet` if `showCart` is on, since
+ * the trigger opens that sheet.
+ */
+export declare function ShopHeader({ onBack, onMenu, showCart, backLabel, menuLabel, className, }: ShopHeaderProps): JSX.Element;
+
+export declare interface ShopHeaderProps {
+    /**
+     * Back control. Omit it and the slot stays empty but reserved — a host whose own
+     * navigation already provides a back affordance should not get a second one.
+     */
+    onBack?: () => void;
+    /** Overflow menu. Omitted by default: a control that opens nothing is worse than none. */
+    onMenu?: () => void;
+    /** The cart icon and its live count. */
+    showCart?: boolean;
+    /** Accessible name for the back control, for a host that is not in English. */
+    backLabel?: string;
+    menuLabel?: string;
+    className?: string;
+}
+
+/**
+ * The replacement for `next/image` inside the SDK.
+ *
+ * `next/image` cannot come with us: it needs the Next runtime and its optimiser
+ * endpoint, and the SDK runs in DAZN's bundle where neither exists. So this is a plain
+ * `<img>` with the platform features that actually carry the weight — native lazy
+ * loading, `decoding="async"`, `sizes`, and `fetchpriority` for the LCP image.
+ *
+ * **What is genuinely lost is on-the-fly resizing and format negotiation** (AVIF/WebP
+ * per browser). That is not something a component can polyfill — it is a serving
+ * concern. Whoever serves the catalogue media should emit `srcset`-ready derivatives
+ * and modern formats; until then, this renders the source as given rather than
+ * pretending to optimise it.
+ *
+ * The one rewrite it does perform is rebasing **root-relative** paths onto the host's
+ * `assetBaseUrl` — see {@link resolveAssetUrl}. Without it the SDK's own design imagery
+ * is requested from the host's origin, which does not serve it.
+ */
+export declare function ShopImage({ src, alt, fill, width, height, sizes, className, style, priority, }: ShopImageProps): JSX.Element;
+
+export declare interface ShopImageProps {
+    src: string;
+    alt: string;
+    /**
+     * Fill the positioned ancestor, as `next/image`'s `fill` does. The parent must be
+     * `position: relative` (or absolute/fixed) — same requirement, same reason.
+     */
+    fill?: boolean;
+    width?: number;
+    height?: number;
+    sizes?: string;
+    className?: string;
+    style?: CSSProperties;
+    /**
+     * Above-the-fold. Sets `fetchpriority="high"` and opts out of lazy loading.
+     *
+     * Named `priority` to match the prop the components already pass, so porting a
+     * component is an import change rather than a rename at every call site.
+     */
+    priority?: boolean;
+}
+
+/**
+ * The replacement for `next/link` inside the SDK. **We never touch the address bar** —
+ * this calls the host's `navigate` and lets the host decide what a route change means.
+ *
+ * It still renders a real `<a href>` rather than a `<div onClick>`, because that is what
+ * gives keyboard activation, focus order, a middle-click that opens a new tab, and a
+ * screen-reader announcement of "link" — none of which a click handler provides. The
+ * default is then prevented so the host router, not the browser, performs the
+ * navigation.
+ *
+ * Modified clicks (⌘/ctrl/shift/alt, or a non-primary button) are deliberately left
+ * alone: a fan holding ⌘ is asking the *browser* for a new tab, and intercepting that
+ * is the single most irritating thing a client-side router can do.
+ */
+export declare function ShopLink({ to, children, ...rest }: ShopLinkProps): JSX.Element;
+
+export declare interface ShopLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | 'onClick'> {
+    to: ShopRoute;
+    children: ReactNode;
+}
+
+/**
+ * The public surface DAZN programs against. Everything here is a **contract**, not an
+ * implementation detail — see the versioning policy in the component SDK specification.
+ */
+/** A storefront-relative identifier. NOT a URL we expect to exist on the host. */
+export declare type ShopRoute = '/' | `/category/${string}` | `/product/${string}` | '/cart';
+
+/**
+ * Request: the shopping session id and the one-time code, exactly as they arrive on the
+ * redirect URL's `session` and `code` query parameters.
+ *
+ * Named for what DAZN's redirect calls them rather than for what `validate-session` calls
+ * them — DAZN's own two endpoints disagree (`session` on the way in, `sessionId` on the
+ * way out), and the storefront only ever sees the redirect.
+ */
+declare const ShopSessionRequest: z.ZodObject<{
+    session: z.ZodString;
+    code: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    code: string;
+    session: string;
+}, {
+    code: string;
+    session: string;
+}>;
+
+declare type ShopSessionRequest = z.infer<typeof ShopSessionRequest>;
+
+/**
+ * The root element of a storefront screen: base typography, element defaults, and a
+ * palette.
+ *
+ * Both halves of this were previously the host's job by accident. The typography lived in
+ * our Next app's `globals.css` on `<body>`, and the dark palette was switched on by a
+ * route-watching `ThemeController` that set `data-theme` on `<html>`. Neither travelled
+ * with the components into this package, so a host mounting `<CategoryView>` got a screen
+ * designed dark rendered on a light palette in the host's own body font — every component
+ * individually correct, the screen as a whole wrong.
+ *
+ * **`tone` is the only input, and the provider's `theme` no longer overrides it.**
+ *
+ * It used to. The reasoning was that a host wanting one palette throughout should be able
+ * to say so — but the storefront has no light and dark of the same screen to choose
+ * between. Each screen is drawn once, in one palette: the shop entry and category pages
+ * are dark, the PDP and cart are light. There is no light version of the dark hero, so
+ * `theme="light"` did not render one; it repainted the tokens underneath a screen whose
+ * artwork, photography and contrast were all built for the other palette.
+ *
+ * DAZN set `theme="light"` and got a dark hero photograph with near-black button text on
+ * it — a screen that exists in no design, produced by an option that sounded reasonable.
+ * The prop is still accepted so that setting it does not break a host's build, and it
+ * still reaches the context for hosts reading it, but it no longer decides what a screen
+ * looks like. Black screens stay black; light screens stay light.
+ *
+ * `data-shop-theme` is a real attribute rather than a hashed module class so the token
+ * remap can live once in `theme.css` beside the values it overrides, and so a host can
+ * scope our palette onto a subtree of their own if they ever need to.
+ *
+ * **Anything that paints its own background must be one of these, not merely look like
+ * one.** Setting `background: var(--color-surface-default)` on an element without also
+ * setting `color` leaves the text inheriting from the host's `<body>` — so a light sheet
+ * in a dark host app renders white text on white. That is what happened to the cart
+ * bottom sheet, and it was invisible in our own app because our `<body>` happened to
+ * carry a matching colour. Hence the forwarded props and ref: a surface has to be usable
+ * **as** a dialog or a layout element, or callers will reach for the CSS shortcut again.
+ */
+export declare const ShopSurface: ForwardRefExoticComponent<ShopSurfaceProps & RefAttributes<HTMLDivElement>>;
+
+export declare interface ShopSurfaceProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    /**
+     * The palette this screen is **designed** in — dark for the shop entry and category,
+     * light for the PDP and cart. This is the whole answer: nothing overrides it.
+     */
+    tone: ShopTone;
+    /**
+     * Paint the full height of the viewport, not just the height of the content.
+     *
+     * On for a screen, off for anything mounted inside one. A screen that stops at its
+     * content leaves the host's own background showing below it, and the host's background
+     * is not ours to predict — DAZN's app is dark, so a short light cart rendered as a white
+     * card floating on black.
+     */
+    fill?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+
+export declare type ShopTone = 'dark' | 'light';
+
+/**
+ * Category-wide sizing help, shown in the PDP "Size guide" overlay.
+ *
+ * `rows` is a measurement table (one row per size). It is **optional and may be empty**:
+ * DAZN has not supplied a measurement chart, and garment measurements are the kind of
+ * value that must never be guessed — a fabricated chest measurement sends a fan the
+ * wrong size. A guide with `notes` but no `rows` is valid and renders as fit guidance
+ * alone; a consumer must not synthesise the missing numbers.
+ *
+ * The array fields are `.optional()` rather than `.default([])` deliberately. A zod
+ * default makes the schema's input and output types diverge, and this package ships two
+ * declaration copies (`dist/` for the root export, `client/` for the typed client) — so
+ * a divergent field makes the two `Product` types structurally unequal and every
+ * consumer that mixes the entry points fails to compile.
+ */
+declare const SizeGuide: z.ZodObject<{
+    title: z.ZodString;
+    /** Column headings for `rows`, e.g. `['Size', 'Chest (cm)', 'Length (cm)']`. */
+    columns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** One row per size; each row's length matches `columns`. */
+    rows: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString, "many">, "many">>;
+    /** Free-text fit guidance, e.g. "Relaxed, slightly oversized fit". */
+    notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    columns?: string[] | undefined;
+    rows?: string[][] | undefined;
+    notes?: string[] | undefined;
+}, {
+    title: string;
+    columns?: string[] | undefined;
+    rows?: string[][] | undefined;
+    notes?: string[] | undefined;
+}>;
+
+declare type SizeGuide = z.infer<typeof SizeGuide>;
+
+/**
+ * The category-wide size-guide overlay (28 Jul kickoff: "a category-wide size guide
+ * overlay pop-up"), presented as a bottom sheet to match the other PDP overlays.
+ *
+ * Renders whatever the guide actually carries. DAZN has supplied **no measurement
+ * chart**, so today every guide has `notes` and no `rows`, and the table simply does not
+ * appear — the component must never fabricate measurements to fill it, because a wrong
+ * chest figure sends a fan the wrong size. When the real chart arrives the table renders
+ * with no code change.
+ */
+export declare function SizeGuideSheet({ guide, onClose }: {
+    guide: SizeGuide;
+    onClose: () => void;
+}): JSX.Element;
+
+export declare interface SizeOption {
+    value: string;
+    available: boolean;
+}
+
+/**
+ * Distinct sizes. `available` is true when a variant of that size is in stock — filtered
+ * to the given colour when one is selected (so picking a colour disables its unavailable
+ * sizes).
+ */
+export declare function sizeOptions(variants: ProductVariant[], colour?: string | null): SizeOption[];
+
+/**
+ * PDP size selector — square chips (per the DAZN mobile/pdp/size component). A selection
+ * is REQUIRED before add-to-cart; out-of-stock sizes are disabled. On Add without a
+ * choice the parent flips `error` and the message + scroll target appear (buttons stay
+ * enabled per the design note). Chips are a real radiogroup for keyboard + SR support.
+ */
+export declare function SizeSelector({ sizes, selected, onSelect, error, guide, }: SizeSelectorProps): JSX.Element;
+
+export declare interface SizeSelectorProps {
+    sizes: SizeOption[];
+    /** Selected size value, or null when none is chosen yet. */
+    selected: string | null;
+    onSelect: (value: string) => void;
+    /** Show the "select a size" error (set after Add-to-cart is tapped with no selection). */
+    error?: boolean;
+    /**
+     * Category-wide sizing help. Absent = the control is not rendered at all, rather than
+     * opening an empty overlay — until DAZN supplies a measurement chart most categories
+     * have no guide, and a dead "Size guide" button is worse than none.
+     */
+    guide?: SizeGuide;
+}
+
+/**
+ * Content placeholder for loading states. Prefer skeletons over full-page spinners.
+ * Marked aria-hidden and respects reduced motion (shimmer disabled globally).
+ */
+export declare function Skeleton({ width, height, radius, className, circle }: SkeletonProps): JSX.Element;
+
+export declare interface SkeletonProps {
+    width?: number | string;
+    height?: number | string;
+    radius?: number | string;
+    className?: string;
+    /** Render as a circle (avatars/thumbnails). */
+    circle?: boolean;
+}
+
+/** Order-status pill mapping the OrderStatus enum to a success/neutral/critical tone. */
+export declare function StatusBadge({ status }: StatusBadgeProps): JSX.Element;
+
+export declare interface StatusBadgeProps {
+    status: OrderStatus;
+}
+
+/** Bottom-pinned CTA bar, safe-area aware. Holds one or two primary actions. */
+export declare function StickyCtaBar({ children, info }: StickyCtaBarProps): JSX.Element;
+
+export declare interface StickyCtaBarProps {
+    children: ReactNode;
+    /** Optional content shown above the actions (e.g. a total). */
+    info?: ReactNode;
+}
+
+export declare function swatchColour(name: string): string;
+
+/** An optional inline action, e.g. the undo offered after removing a cart line. */
+export declare interface ToastAction {
+    label: string;
+    onAction: () => void;
+}
+
+declare interface ToastApi {
+    show: (message: string, tone?: ToastTone, action?: ToastAction) => void;
+}
+
+export declare function ToastProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare type ToastTone = 'neutral' | 'success' | 'critical';
+
+/** Resolve UI copy + behaviour for an API error code (unknown → generic retriable). */
+export declare function treatmentFor(code: ErrorCode | undefined): ErrorTreatment;
+
+/** `PATCH /v1/cart/items/{sku}` — change the quantity. */
+declare const UpdateCartItemRequest: z.ZodObject<{
+    qty: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    qty: number;
+}, {
+    qty: number;
+}>;
+
+declare type UpdateCartItemRequest = z.infer<typeof UpdateCartItemRequest>;
+
+/**
+ * Resolve an SDK asset path against the host's configured base. Identity outside a
+ * provider, and identity when no base is configured — so our own app, which serves these
+ * paths itself, needs no configuration.
+ */
+export declare function useAssetUrl(): (src: string) => string;
+
+/**
+ * How many units are in the cart, for a header badge.
+ *
+ * `null` means **not known** — no provider, no session yet, or the read failed — and is
+ * deliberately distinct from `0`. A badge must render nothing for `null` and nothing for
+ * `0`, but a caller that wants to say "your cart is empty" needs to tell the two apart,
+ * and a hook that collapses them takes that away.
+ *
+ * Reads once on mount, then follows the `cart_updated` event rather than re-fetching. The
+ * event carries the authoritative count from the mutation's own response, so the badge is
+ * exact rather than optimistic, and adding from the PDP updates a badge in the header
+ * without either component knowing the other exists.
+ *
+ * Counts **units, not lines** — three of one tee reads as 3. That is the convention the
+ * `cart_updated` event already uses, and the two must not disagree.
+ */
+export declare function useCartCount(): number | null;
+
+/**
+ * Access the cart sheet. Returns `null` outside the provider rather than throwing, so a
+ * component can offer "open the sheet" where it is available and fall back to the
+ * `/cart` route where it is not — a header rendered in a test harness without the
+ * provider should not crash the harness.
+ */
+export declare function useCartSheet(): CartSheetApi | null;
+
+/**
+ * Format server-authoritative {@link Money} for display. Formatting ONLY — never
+ * computes totals, tax or discounts, and never does float arithmetic on money.
+ *
+ * The locale resolution order changed when this moved into the SDK, and the order
+ * matters: **provider `locale` → provider `market.lang` → browser locale**.
+ *
+ * The app version read `navigator.language` alone. Mounted in a host page that is
+ * already rendering a chosen market, the browser locale is the *wrong* answer — a fan
+ * in Spain with an English-language device would see Spanish-market prices formatted to
+ * en-GB conventions. The host tells us the market, so the host's answer wins.
+ *
+ * Works without a provider, falling back to the browser locale exactly as before.
+ * Formatting a price needs no API client, and requiring one would make every component
+ * that shows a price untestable in isolation.
+ */
+export declare function useMoney(defaultLocale?: string): {
+    format: (money: Money, localeOverride?: string) => string;
+};
+
+/**
+ * Navigate to a storefront route, or `null` outside a provider.
+ *
+ * `null` rather than a throw or a no-op: it lets {@link ShopLink} tell the difference
+ * between "the host wants to handle this" and "nobody is listening", and fall back to
+ * being an ordinary link in the second case. A no-op would instead swallow the click and
+ * leave a link that looks fine and does nothing.
+ */
+export declare function useNavigate(): ((to: ShopRoute) => void) | null;
+
+/** The typed, schema-validating commerce client. Requires a provider. */
+export declare function useShopApi(): DaznClient;
+
+/** Raise an event to the host. Silently dropped outside a provider. */
+export declare function useShopEvent(): OnEvent;
+
+/**
+ * Read the shop context, or `null` outside a provider.
+ *
+ * Not every capability needs a provider, and pretending otherwise makes the components
+ * harder to test and harder to adopt piecemeal. Formatting a price and rendering a link
+ * are both meaningful on their own; reaching the API is not. So the strictness is per
+ * capability, below, rather than blanket.
+ */
+export declare function useShopOptional(): ShopContextValue | null;
+
+/**
+ * Access the toast API. Always returns something usable.
+ *
+ * This used to throw outside `<ToastProvider>`, and that was wrong on the project's own
+ * principle that strictness is **per capability**: `useShopApi` throws because reaching
+ * the API genuinely cannot degrade, but a toast can. Worse, it made the specification's
+ * opening example — one `<DaznShopProvider>` with `<CartView>` beneath it — crash the
+ * entire tree on mount, because `CartView` raises toasts and nothing had mounted a
+ * provider. With no error boundary above it, a host following our own documentation got
+ * a blank page.
+ *
+ * Without a `<ToastProvider>` the message still goes somewhere useful: it is emitted to
+ * the host as a `notification` event if there is a shop provider to emit through, which
+ * is exactly what `notifications: 'host'` does deliberately. Failing that it is dropped,
+ * because a missing toast is a cosmetic loss and taking the storefront down over one is
+ * not a trade worth making.
+ */
+export declare function useToast(): ToastApi;
+
+/**
+ * A one-line label for a chosen variant, e.g. `Black · M`.
+ *
+ * Composed here rather than server-side because the separator and the order are
+ * presentation. Colour leads and size follows, matching how the PDP asks for them;
+ * anything else the catalogue carries is appended in its own order rather than dropped,
+ * so a product with a third dimension is not silently flattened.
+ *
+ * Returns `undefined` for an absent or empty map, so a caller can skip the element
+ * entirely instead of rendering a blank line.
+ */
+export declare function variantLabel(attributes?: Record<string, string>): string | undefined;
+
+/**
+ * Variant picker. A selection is REQUIRED before add-to-cart; out-of-stock options are
+ * disabled and cannot be chosen. When nothing is selected the parent blocks the CTA.
+ */
+export declare function VariantSelector({ variants, selectedSku, onSelect, labelAttribute, }: VariantSelectorProps): JSX.Element;
+
+export declare interface VariantSelectorProps {
+    variants: ProductVariant[];
+    /** SKU of the selected variant, or null when none is chosen yet. */
+    selectedSku: string | null;
+    onSelect: (sku: string) => void;
+    /** Attribute key to render as the option label (e.g. "size"). */
+    labelAttribute?: string;
+}
+
+/** "Why shop with us" reassurance rows. */
+export declare function WhyUs({ items }: {
+    items: WhyUsItem[];
+}): JSX.Element;
+
+declare interface WhyUsItem {
+    icon?: 'payment' | 'delivery' | 'returns';
+    title: string;
+    body: string;
+}
+
+export { }