@asteby/storefront-react 0.19.0 → 0.21.0

package/dist/account.d.cts

@@ -1,9 +1,12 @@
 import * as react from 'react';
-import { ComponentType, ReactNode } from 'react';
-import { CustomerCapabilities } from '@asteby/storefront';
+import { ComponentType, ReactNode, MouseEvent } from 'react';
+import { CustomerCapabilities, Order, NextAction, OrderProgress as OrderProgress$1, OrderLine, Shipment, ShipmentMap, InvoiceDoc, InvoiceSummary, InvoiceFileKind, PendingPayment, PaymentInfo, Refund, StorefrontClient, Connection, Money } from '@asteby/storefront';
 import { a as CheckoutFieldClassNames } from './fields-vnMUi2HB.cjs';
 import { A as AuthActionData, c as AuthStep, a as AuthErrorCode } from './types-D7pVK0GK.cjs';
 export { b as AuthIntent } from './types-D7pVK0GK.cjs';
+import { a as ProductPreviewClassNames, e as ProductThumbImage } from './product-preview-DRtLWGLS.cjs';
+export { P as ProductPreview, b as ProductPreviewProps, c as ProductThumb, f as ProductThumbProps, g as ProductThumbStack, h as ProductThumbStackProps, p as productInitials } from './product-preview-DRtLWGLS.cjs';
+import './components-B5XhSH-m.cjs';
 
 type AccountAuthView = 'login' | 'register' | 'otp-email' | 'forgot' | AuthStep;
 type AccountAuthMessages = {
@@ -127,4 +130,497 @@ type PostPurchaseAccountPromptProps = {
  */
 declare function PostPurchaseAccountPrompt({ email, capabilities, data, next, pending, form: FormTag, action, headingLevel, loginHref, locale, messages, classNames: cx, children, }: PostPurchaseAccountPromptProps): react.JSX.Element | null;
 
-export { AccountAuth, type AccountAuthClassNames, type AccountAuthMessages, type AccountAuthProps, type AccountAuthView, type AccountFormProps, AuthActionData, AuthErrorCode, AuthStep, PostPurchaseAccountPrompt, type PostPurchaseAccountPromptClassNames, type PostPurchaseAccountPromptMessages, type PostPurchaseAccountPromptProps, accountAuthMessages, postPurchaseAccountPromptMessages };
+/**
+ * Texts of the order screens (`OrderList`, `OrderProgress`, `NextActionBar`, `ShipmentCard`, `InvoiceList`,
+ * `PendingPaymentCard`, `RefundList`). Spanish (es-MX) by default, English with `en*`, anything with `messages`.
+ * Server enums are open: every group has a `*.unknown` text so a value this SDK has never seen reads as plain words,
+ * never as a raw code.
+ */
+
+declare const ES: {
+    readonly 'order.number': "Pedido {number}";
+    readonly 'order.placed': "Realizado el {date}";
+    readonly 'order.total': "Total";
+    readonly 'order.view': "Ver pedido";
+    readonly 'order.items.one': "{count} artículo";
+    readonly 'order.items.other': "{count} artículos";
+    readonly 'order.lines': "Artículos del pedido";
+    readonly 'order.line.quantity': "Cantidad {n}";
+    readonly 'order.line.each': "{price} c/u";
+    readonly 'order.line.unavailable': "Producto no disponible";
+    readonly 'order.productsMore': "y {n} más";
+    readonly 'order.stepOf': "Paso {n} de {total}: {step}";
+    readonly 'order.listLabel': "Tus pedidos";
+    readonly 'order.loading': "Cargando tus pedidos";
+    readonly 'order.loadMore': "Ver más pedidos";
+    readonly 'order.loadingMore': "Cargando…";
+    readonly 'order.error': "No pudimos cargar tus pedidos. Tus compras están a salvo.";
+    readonly 'order.retry': "Reintentar";
+    readonly 'order.emptyTitle': "Aún no tienes pedidos";
+    readonly 'order.emptyBody': "Cuando compres, aquí verás el estado y el envío de cada pedido.";
+    readonly 'order.emptyGuest': "¿Compraste como invitado? Verifica tu correo para ver aquí tus pedidos.";
+    readonly 'stage.pending_payment': "Esperando pago";
+    readonly 'stage.paid': "Pagado";
+    readonly 'stage.preparing': "En preparación";
+    readonly 'stage.ready_for_pickup': "Listo para recoger";
+    readonly 'stage.shipped': "Enviado";
+    readonly 'stage.in_transit': "En camino";
+    readonly 'stage.out_for_delivery': "En reparto";
+    readonly 'stage.delivered': "Entregado";
+    readonly 'stage.cancelled': "Cancelado";
+    readonly 'stage.refunded': "Reembolsado";
+    readonly 'stage.unknown': "En proceso";
+    readonly 'progress.label': "Progreso del pedido";
+    readonly 'step.paid': "Pagado";
+    readonly 'step.preparing': "En preparación";
+    readonly 'step.shipped': "Enviado";
+    readonly 'step.in_transit': "En camino";
+    readonly 'step.ready_for_pickup': "Listo para recoger";
+    readonly 'step.delivered': "Entregado";
+    readonly 'step.unknown': "Siguiente paso";
+    readonly 'stepState.done': "completado";
+    readonly 'stepState.current': "paso actual";
+    readonly 'stepState.pending': "pendiente";
+    readonly 'stepState.problem': "con incidencia";
+    readonly 'problem.delivery_exception': "Hubo un problema con la entrega. Contacta a la tienda si no se resuelve.";
+    readonly 'problem.returned': "El paquete regresó a la tienda. Contáctanos para coordinar un nuevo envío.";
+    readonly 'problem.lost': "No encontramos tu paquete. Contáctanos y lo resolvemos.";
+    readonly 'problem.payment_failed': "El pago no se completó. Puedes intentarlo de nuevo.";
+    readonly 'problem.unknown': "Tu pedido tiene una incidencia. Contacta a la tienda.";
+    readonly 'progress.cancelled': "Este pedido fue cancelado.";
+    readonly 'progress.refunded': "Este pedido fue reembolsado.";
+    readonly 'action.pay': "Pagar ahora";
+    readonly 'action.track': "Rastrear envío";
+    readonly 'action.pickup': "Recoger en sucursal";
+    readonly 'action.download_invoice': "Descargar factura";
+    readonly 'action.request_invoice': "Solicitar factura";
+    readonly 'action.correct_invoice_data': "Corregir datos de facturación";
+    readonly 'action.contact_store': "Contactar a la tienda";
+    readonly 'action.unknown': "Ver detalle";
+    readonly 'action.newTab': "(se abre en una pestaña nueva)";
+    readonly 'action.label': "Siguiente paso del pedido";
+    readonly 'shipment.title': "Envío";
+    readonly 'shipment.return': "Devolución";
+    readonly 'shipment.carrier': "Paquetería";
+    readonly 'shipment.service': "Servicio";
+    readonly 'shipment.number': "Número de guía";
+    readonly 'shipment.copy': "Copiar";
+    readonly 'shipment.copied': "Copiado";
+    readonly 'shipment.copyFailed': "No pudimos copiar; selecciona el texto.";
+    readonly 'shipment.track': "Rastrear con {carrier}";
+    readonly 'shipment.trackGeneric': "Rastrear envío";
+    readonly 'shipment.promised': "Llega a más tardar el {date}";
+    readonly 'shipment.delivered': "Entregado el {date}";
+    readonly 'shipment.shipped': "Enviado el {date}";
+    readonly 'shipment.events': "Movimientos";
+    readonly 'shipment.noEvents': "La paquetería aún no registra movimientos; suele tardar 24 horas.";
+    readonly 'shipment.showAll': "Ver todo ({count})";
+    readonly 'shipment.showLess': "Ver menos";
+    readonly 'shipment.returnLabel': "Guía de devolución";
+    readonly 'shipment.test': "De prueba";
+    readonly 'shipment.testNote': "Envío de prueba: no es un envío real.";
+    readonly 'shipment.preparing': "Preparando tu envío";
+    readonly 'shipment.status.pending': "Preparando envío";
+    readonly 'shipment.status.label_created': "Guía generada";
+    readonly 'shipment.status.in_transit': "En camino";
+    readonly 'shipment.status.out_for_delivery': "En reparto";
+    readonly 'shipment.status.delivered': "Entregado";
+    readonly 'shipment.status.exception': "Incidencia en la entrega";
+    readonly 'shipment.status.returned': "Devuelto a la tienda";
+    readonly 'shipment.status.lost': "Extraviado";
+    readonly 'shipment.status.cancelled': "Cancelado";
+    readonly 'shipment.status.unknown': "En proceso";
+    readonly 'shipment.eventFrom': "{location}";
+    readonly 'invoice.title': "Facturas";
+    readonly 'invoice.invoice': "Factura";
+    readonly 'invoice.creditNote': "Nota de crédito";
+    readonly 'invoice.creditNoteOf': "Corrige la factura {folio}";
+    readonly 'invoice.folio': "Folio fiscal";
+    readonly 'invoice.series': "Serie y folio";
+    readonly 'invoice.issued': "Emitida el {date}";
+    readonly 'invoice.total': "Total";
+    readonly 'invoice.pdf': "Descargar PDF";
+    readonly 'invoice.xml': "Descargar XML";
+    readonly 'invoice.downloadOf': "{action}, {kind} {name}";
+    readonly 'invoice.none': "Aún no hay facturas de este pedido.";
+    readonly 'invoice.test': "Factura de prueba, sin validez";
+    readonly 'invoice.status.issued': "Emitida";
+    readonly 'invoice.status.pending': "En proceso";
+    readonly 'invoice.status.cancelled': "Cancelada";
+    readonly 'invoice.status.error': "No se pudo emitir";
+    readonly 'invoice.status.unknown': "En proceso";
+    readonly 'invoice.statusNote.pending': "La estamos generando; te avisaremos cuando esté lista.";
+    readonly 'invoice.statusNote.error': "Contacta a la tienda para resolverlo.";
+    readonly 'invoice.statusNote.cancelled': "Esta factura fue cancelada y ya no tiene validez.";
+    readonly 'pending.title': "Pendientes de pago";
+    readonly 'pending.intro': "Tu pedido se genera en cuanto confirmamos el pago. Paga con la ficha antes de que venza.";
+    readonly 'pending.waiting': "Esperando pago";
+    readonly 'pending.expired': "Vencida";
+    readonly 'pending.reference': "Referencia";
+    readonly 'pending.clabe': "CLABE";
+    readonly 'pending.expires': "Vence el {date}";
+    readonly 'pending.expiredOn': "Venció el {date}";
+    readonly 'pending.total': "Total";
+    readonly 'pending.copyReference': "Copiar referencia";
+    readonly 'pending.copyClabe': "Copiar CLABE";
+    readonly 'pending.copied': "Copiada";
+    readonly 'pending.copyFailed': "No pudimos copiar; selecciona el texto.";
+    readonly 'pending.print': "Ver e imprimir ficha";
+    readonly 'pending.download': "Descargar ficha";
+    readonly 'pending.expiredNote': "Esta ficha ya no es válida. Haz tu pedido de nuevo.";
+    readonly 'pending.barcode': "Código de barras {code}";
+    readonly 'pending.method.oxxo': "OXXO";
+    readonly 'pending.method.spei': "Transferencia SPEI";
+    readonly 'pending.method.bank_transfer': "Transferencia bancaria";
+    readonly 'pending.method.bank_deposit': "Depósito bancario";
+    readonly 'pending.method.cash': "Pago en efectivo";
+    readonly 'pending.method.unknown': "Pago en efectivo";
+    readonly 'refund.title': "Reembolsos";
+    readonly 'refund.status.requested': "Solicitado";
+    readonly 'refund.status.processing': "En proceso";
+    readonly 'refund.status.completed': "Completado";
+    readonly 'refund.status.failed': "No se pudo completar";
+    readonly 'refund.status.unknown': "En proceso";
+    readonly 'refund.requested': "Solicitado el {date}";
+    readonly 'refund.completed': "Completado el {date}";
+    readonly 'refund.none': "Este pedido no tiene reembolsos.";
+    readonly 'payment.title': "Pagos";
+    readonly 'payment.status.paid': "Pagado";
+    readonly 'payment.status.pending': "Pendiente";
+    readonly 'payment.status.failed': "Fallido";
+    readonly 'payment.status.refunded': "Reembolsado";
+    readonly 'payment.status.partially_refunded': "Reembolsado parcialmente";
+    readonly 'payment.status.unknown': "En proceso";
+    readonly 'payment.paidOn': "Pagado el {date}";
+    readonly 'section.error': "No pudimos cargar esta sección.";
+    readonly 'section.retry': "Reintentar";
+    readonly 'section.loading': "Cargando";
+};
+type AccountMessageKey = keyof typeof ES;
+type AccountMessages = Record<AccountMessageKey, string>;
+/** Messages for a locale (`es*` default, `en*`), with optional per-key overrides. */
+declare function accountMessages(locale?: string | null, overrides?: Partial<AccountMessages> | null): AccountMessages;
+/** Text for an open enum: `<group>.<value>` when this SDK knows it, else `<group>.unknown`. Never the raw value. */
+declare function enumText(m: AccountMessages, group: string, value: unknown): string;
+
+type AccountTextProps = {
+    /** BCP 47; defaults to the provider's, then `es-MX`. */
+    locale?: string;
+    /** Per-key text overrides (a store's own words). */
+    messages?: Partial<AccountMessages>;
+    /** IANA time zone for dates (`America/Mexico_City`). Pass the store's own to get the same text on server and browser. */
+    timeZone?: string;
+};
+
+type OrderTone = 'done' | 'current' | 'problem' | 'muted';
+/** Tone of a stage for the store's own colors (`data-sf-tone`). */
+declare function stageTone(stage: string, problem?: unknown): OrderTone;
+type OrderStatusBadgeProps = AccountTextProps & {
+    /** The order (its `progress` or a derived one is used) ... */
+    order?: Order;
+    /** ... or the progress itself. */
+    progress?: OrderProgress$1;
+    className?: string;
+};
+/** Status in words with a semantic tone: `<span data-sf-order-badge data-sf-tone="current">En camino</span>`. */
+declare function OrderStatusBadge({ order, progress, className, ...text }: OrderStatusBadgeProps): react.JSX.Element | null;
+type OrderProgressClassNames = Partial<Record<'root' | 'list' | 'step' | 'marker' | 'label' | 'time' | 'problem' | 'terminal', string>>;
+type OrderProgressProps = AccountTextProps & {
+    /** Pass the order (progress is read or derived) ... */
+    order?: Order;
+    /** ... or the progress. */
+    progress?: OrderProgress$1;
+    /** `compact`: only the current step and "step 3 of 5", for a list card. */
+    variant?: 'full' | 'compact';
+    classNames?: OrderProgressClassNames;
+};
+/**
+ * `<ol>` with the steps paid → preparing → shipped → on its way → delivered (or pickup). The current step carries
+ * `aria-current="step"`; every state also has text for screen readers, and a problem is written out below the list.
+ */
+declare function OrderProgress({ order, progress, variant, classNames: cx, ...text }: OrderProgressProps): react.JSX.Element | null;
+type NextActionBarClassNames = Partial<Record<'root' | 'primary' | 'secondary', string>>;
+type NextActionBarProps = AccountTextProps & {
+    /** The order (its `next_action` is read or derived) ... */
+    order?: Order;
+    /** ... or the action itself. */
+    action?: NextAction | null;
+    /**
+     * Where each action goes in YOUR store: `pay` → the voucher/checkout, `download_invoice` → your invoice-file route,
+     * `request_invoice` / `correct_invoice_data` → your invoice form, `contact_store` → your contact page. `track` and
+     * `pickup` default to the action's own `https` link. Return `null` when there is nowhere to go: the bar then renders
+     * a button only if `onAction` handles it, and nothing otherwise.
+     */
+    hrefFor?: (action: NextAction) => string | null | undefined;
+    /** Click handler for actions with no link (`pay` opening a dialog...). Called with the action. */
+    onAction?: (action: NextAction, event: MouseEvent<HTMLElement>) => void;
+    /** Secondary buttons next to the primary one (copy tracking number, request return...). */
+    secondary?: ReactNode;
+    classNames?: NextActionBarClassNames;
+};
+/**
+ * ONE primary call to action: "Rastrear envío", "Descargar factura", "Pagar ahora"... Links that leave the store carry
+ * `rel="noopener noreferrer"` and a hidden "(opens in a new tab)". Nothing renders for `none` or an action with no
+ * way to act.
+ */
+declare function NextActionBar({ order, action, hrefFor, onAction, secondary, classNames: cx, ...text }: NextActionBarProps): react.JSX.Element | null;
+
+type OrderCardClassNames = Partial<Record<'root' | 'header' | 'products' | 'number' | 'link' | 'meta' | 'badge' | 'summary' | 'shipment' | 'footer' | 'total' | 'actions', string>> & {
+    progress?: OrderProgressClassNames;
+    action?: NextActionBarClassNames;
+};
+type OrderCardProps = AccountTextProps & {
+    order: Order;
+    /** Where the order detail lives in your store. The whole card is reached through the number's link. */
+    orderHref: (order: Order) => string;
+    /** Where each next action goes (see `NextActionBar.hrefFor`). */
+    actionHref?: (action: NextAction, order: Order) => string | null | undefined;
+    onAction?: (action: NextAction, order: Order) => void;
+    /** Heading level of the order number (default 3). */
+    headingLevel?: 2 | 3 | 4;
+    classNames?: OrderCardClassNames;
+};
+declare function OrderCard({ order, orderHref, actionHref, onAction, headingLevel, classNames: cx, ...text }: OrderCardProps): react.JSX.Element;
+type OrderListClassNames = Partial<Record<'root' | 'list' | 'item' | 'skeleton' | 'empty' | 'emptyTitle' | 'emptyBody' | 'emptyGuest' | 'error' | 'retry' | 'more', string>> & {
+    card?: OrderCardClassNames;
+};
+type OrderListProps = AccountTextProps & Pick<OrderCardProps, 'orderHref' | 'actionHref' | 'onAction' | 'headingLevel'> & {
+    orders?: readonly Order[] | null;
+    status?: 'loading' | 'ready' | 'error';
+    /** Skeleton cards while loading (default 3). */
+    skeletons?: number;
+    onRetry?: () => void;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onLoadMore?: () => void;
+    /** Your call to action in the empty state ("Ver catálogo"). */
+    emptyAction?: ReactNode;
+    /** Show "bought as a guest? verify your email" in the empty state (default true). */
+    guestHint?: boolean;
+    classNames?: OrderListClassNames;
+};
+declare function OrderList({ orders, status, skeletons, onRetry, hasMore, loadingMore, onLoadMore, emptyAction, guestHint, orderHref, actionHref, onAction, headingLevel, classNames: cx, ...text }: OrderListProps): react.JSX.Element;
+
+/** The picture of a line when it carries a usable URL. */
+declare function lineImage(line: Partial<OrderLine> | null | undefined): ProductThumbImage | null;
+type OrderLinesClassNames = Partial<Record<'root' | 'list' | 'item', string>> & {
+    preview?: ProductPreviewClassNames;
+};
+type OrderLinesProps = AccountTextProps & {
+    order: Pick<Order, 'lines'>;
+    /** Product page of a line (return `null` for none). */
+    lineHref?: (line: OrderLine) => string | null | undefined;
+    /** Thumb side in px. Default 64. */
+    size?: number;
+    /** Heading of the list for screen readers. */
+    label?: string;
+    classNames?: OrderLinesClassNames;
+};
+declare function OrderLines({ order, lineHref, size, label, classNames: cx, ...text }: OrderLinesProps): react.JSX.Element | null;
+/** The products of an order as overlapped pictures with "+N": the glance of an order card. */
+declare function OrderProductsStack({ order, size, max, className, ...text }: AccountTextProps & {
+    order: Pick<Order, 'lines'>;
+    size?: number;
+    max?: number;
+    className?: string;
+}): react.JSX.Element | null;
+
+type ShipmentCardClassNames = Partial<Record<'root' | 'header' | 'carrier' | 'status' | 'meta' | 'number' | 'actions' | 'link' | 'copy' | 'events' | 'event' | 'toggle' | 'empty' | 'test' | 'map', string>>;
+/** What `renderMap` receives. */
+type ShipmentMapSlotProps = {
+    shipment: Shipment;
+    map: ShipmentMap;
+};
+type ShipmentCardProps = AccountTextProps & {
+    shipment: Shipment;
+    /** A sandbox shipment: `hide` (default) renders nothing; `mark` shows it labelled "test", without number or link. */
+    testMode?: 'hide' | 'mark';
+    /** How many events show before "Show all". Default 3. */
+    eventsPreview?: number;
+    /** The carrier's logo/brand mark (e.g. `<BrandMark brand={shipment.carrier_logo_key} />` from `/checkout`); kept out of this bundle on purpose. */
+    renderCarrierMark?: (shipment: Shipment) => ReactNode;
+    /** Slot for the map (F7). Called only when the shipment has a `map`. */
+    renderMap?: (props: ShipmentMapSlotProps) => ReactNode;
+    /** Heading level of the title (default 3). */
+    headingLevel?: 2 | 3 | 4 | 5;
+    classNames?: ShipmentCardClassNames;
+};
+declare function ShipmentCard({ shipment, testMode, eventsPreview, renderCarrierMark, renderMap, headingLevel, classNames: cx, ...text }: ShipmentCardProps): react.JSX.Element | null;
+
+type InvoiceListClassNames = Partial<Record<'root' | 'title' | 'group' | 'doc' | 'status' | 'meta' | 'note' | 'actions' | 'download' | 'creditNotes' | 'test' | 'error' | 'retry' | 'empty', string>>;
+type InvoiceListProps = AccountTextProps & {
+    invoices?: readonly InvoiceDoc[] | null;
+    /** The order's invoice summary, handed to `renderSummary` when there are no documents. */
+    summary?: InvoiceSummary | null;
+    /** Draws the summary (request, needs data, being generated...): `(s) => <InvoiceStatusCard invoice={s} requestHref="/factura" />`. */
+    renderSummary?: (summary: InvoiceSummary) => ReactNode;
+    /** Your authenticated download route for a file of a document, e.g. `/cuenta/pedidos/${order}/facturas/${doc.id}.${kind}`. */
+    fileHref?: (doc: InvoiceDoc, kind: InvoiceFileKind) => string | null | undefined;
+    /** Alternative to `fileHref`: a handler (opens your own download flow). */
+    onDownload?: (doc: InvoiceDoc, kind: InvoiceFileKind) => void;
+    /** The server could not read the invoices (`order.degraded` has `invoices`): shows a recoverable error. */
+    degraded?: boolean;
+    onRetry?: () => void;
+    /** A sandbox invoice: `mark` (default) shows it labelled and with no download; `hide` removes it. */
+    testMode?: 'hide' | 'mark';
+    /** Money formatter is `Intl`; the order's currency comes with each total. */
+    headingLevel?: 2 | 3 | 4;
+    /** Content under the list (e.g. a "Request invoice" button). */
+    children?: ReactNode;
+    classNames?: InvoiceListClassNames;
+};
+declare function InvoiceList({ invoices, summary, renderSummary, fileHref, onDownload, degraded, onRetry, testMode, headingLevel, children, classNames: cx, ...text }: InvoiceListProps): react.JSX.Element;
+
+type BarcodeProps = {
+    value: string;
+    label: string;
+    height?: number;
+    className?: string;
+};
+/** Code 128 as an inline `<svg role="img">` (no HTML injection). `null` when the value cannot be encoded. */
+declare function Barcode({ value, label, height, className }: BarcodeProps): react.JSX.Element | null;
+type PendingPaymentCardClassNames = Partial<Record<'root' | 'header' | 'method' | 'badge' | 'field' | 'label' | 'value' | 'barcode' | 'expiry' | 'total' | 'note' | 'actions' | 'primary' | 'secondary', string>>;
+type PendingPaymentCardProps = AccountTextProps & {
+    payment: PendingPayment;
+    /** Server route that serves the printable voucher: `(payment, { download })`. Without it the browser builds it. */
+    voucherHref?: (payment: PendingPayment, opts: {
+        download: boolean;
+    }) => string;
+    /** Store name printed on the document built in the browser. */
+    shopName?: string;
+    headingLevel?: 2 | 3 | 4;
+    classNames?: PendingPaymentCardClassNames;
+    children?: ReactNode;
+};
+declare function PendingPaymentCard({ payment, voucherHref, shopName, headingLevel, classNames: cx, children, ...text }: PendingPaymentCardProps): react.JSX.Element | null;
+type PendingPaymentListProps = AccountTextProps & Pick<PendingPaymentCardProps, 'voucherHref' | 'shopName' | 'classNames'> & {
+    payments?: readonly PendingPayment[] | null;
+    headingLevel?: 2 | 3;
+    /** Classes of the section itself. */
+    listClassNames?: Partial<Record<'root' | 'title' | 'intro' | 'list' | 'item', string>>;
+};
+/** "Pendientes de pago": the valid vouchers first, then the expired ones. Renders nothing when there are none. */
+declare function PendingPaymentList({ payments, voucherHref, shopName, classNames, listClassNames: lc, headingLevel, ...text }: PendingPaymentListProps): react.JSX.Element | null;
+
+type RefundListClassNames = Partial<Record<'root' | 'title' | 'list' | 'item' | 'amount' | 'status' | 'meta' | 'empty' | 'error' | 'retry', string>>;
+type RefundListProps = AccountTextProps & {
+    refunds?: readonly Refund[] | null;
+    /** Show the "no refunds" text when empty (default: render nothing, the usual case). */
+    showEmpty?: boolean;
+    /** The server could not read refunds (`order.degraded`): recoverable error. */
+    degraded?: boolean;
+    onRetry?: () => void;
+    headingLevel?: 2 | 3 | 4;
+    classNames?: RefundListClassNames;
+};
+declare function RefundList({ refunds, showEmpty, degraded, onRetry, headingLevel, classNames: cx, ...text }: RefundListProps): react.JSX.Element | null;
+type PaymentSummaryProps = AccountTextProps & {
+    payments?: readonly PaymentInfo[] | null;
+    headingLevel?: 2 | 3 | 4;
+    classNames?: Partial<Record<'root' | 'title' | 'list' | 'item' | 'status' | 'meta', string>>;
+};
+/** What the buyer paid with (card, voucher...) and its status. Renders nothing when the order has no payments. */
+declare function PaymentSummary({ payments, headingLevel, classNames: cx, ...text }: PaymentSummaryProps): react.JSX.Element | null;
+
+/**
+ * Data hooks of the account screens. They talk to the client of the `StorefrontProvider` (or `client`), which must carry
+ * the buyer's session (`withCustomerToken`); on a store that renders on the server, pass what the loader read as
+ * `initial` and nothing is fetched until the buyer asks (`reload`, `loadMore`) or a poll tick fires.
+ *
+ * They never throw: a failure is `status: 'error'` with the `StorefrontError` in `error`, and `reload()` is the retry.
+ * A 404 on one order is `status: 'not_found'` (also when it belongs to someone else: the server does not tell).
+ */
+
+type AccountStatus = 'loading' | 'ready' | 'error' | 'not_found';
+type UseConnectionResult<T> = {
+    status: Exclude<AccountStatus, 'not_found'>;
+    nodes: T[];
+    error: Error | null;
+    hasMore: boolean;
+    loadingMore: boolean;
+    totalCount: number | null;
+    /** Fetches the first page again (the retry). Keeps showing the current list meanwhile. */
+    reload: () => void;
+    /** Appends the next page. */
+    loadMore: () => void;
+};
+type UseCustomerOrdersOptions = {
+    client?: StorefrontClient | null;
+    /** Page size (default 20). */
+    first?: number;
+    /** First page already read on the server: renders at once, nothing is fetched. */
+    initial?: Connection<Order> | null;
+};
+/** The buyer's orders (summaries), newest first, with `loadMore`. */
+declare function useCustomerOrders({ client, first, initial }?: UseCustomerOrdersOptions): UseConnectionResult<Order>;
+type UsePendingPaymentsOptions = UseCustomerOrdersOptions & {
+    initial?: Connection<PendingPayment> | null;
+};
+/** Cash vouchers still waiting for payment. A failure of this section never blocks the orders: it is its own `status`. */
+declare function usePendingPayments({ client, first, initial }?: UsePendingPaymentsOptions): UseConnectionResult<PendingPayment>;
+type UseCustomerOrderOptions = {
+    client?: StorefrontClient | null;
+    /** The order already read on the server (`null` = the server found none: `not_found`). */
+    initial?: Order | null;
+    /**
+     * Re-reads the order every `everyMs` (default 10 s) for at most `forMs` (default 60 s) while `while(order)` is true,
+     * e.g. an invoice being generated: `{ while: (o) => ['queued','issuing'].includes(o.invoice?.stage ?? '') }`.
+     * Polling is silent: the order stays on screen and `refreshing` flips.
+     */
+    poll?: {
+        while: (order: Order) => boolean;
+        everyMs?: number;
+        forMs?: number;
+    };
+};
+type UseCustomerOrderResult = {
+    status: AccountStatus;
+    order: Order | null;
+    error: Error | null;
+    /** A silent re-read is in flight (retry or poll): keep showing `order`. */
+    refreshing: boolean;
+    reload: () => void;
+};
+/** One order with its detail (shipments, invoices, payments, refunds, `degraded`). */
+declare function useCustomerOrder(id: string | null | undefined, { client, initial, poll }?: UseCustomerOrderOptions): UseCustomerOrderResult;
+
+/**
+ * Pure pieces of the cash voucher (OXXO, SPEI, deposit): the normalized `VoucherView` of a `PendingPayment` and the
+ * Code 128 barcode (the one cashiers' readers scan). No React, no DOM: the same code draws the barcode in the page
+ * (`<Barcode>`) and in the printable document (`voucher-document.ts`, loaded only when the buyer prints).
+ */
+
+type VoucherView = {
+    /** `oxxo`, `spei`, ... as the gateway publishes it. */
+    method: string | null;
+    reference: string | null;
+    barcode: string | null;
+    clabe: string | null;
+    expires_at: string | null;
+    amount: Money | null;
+    instructions: string | null;
+};
+/** The voucher of a pending payment; `null` when it has neither reference, barcode nor CLABE (nothing to pay with). */
+declare function voucherOf(p: Pick<PendingPayment, 'payment' | 'total' | 'expires_at'> | null | undefined): VoucherView | null;
+/** The value the barcode encodes: the gateway's `barcode`, else the reference of an OXXO voucher. */
+declare function barcodeValue(v: Pick<VoucherView, 'barcode' | 'method' | 'reference'>): string | null;
+/**
+ * Modules (`1` bar, `0` space) of the Code 128 of `value`: set C (digit pairs) when it is all digits of even length,
+ * set B (printable ASCII) otherwise. `null` when it cannot be encoded.
+ */
+declare function code128Modules(value: string): string | null;
+type BarcodeGeometry = {
+    width: number;
+    height: number;
+    rects: {
+        x: number;
+        w: number;
+    }[];
+};
+/** Bars of the barcode as rectangles (quiet zone of 10 modules each side included in `width`). `null` if not encodable. */
+declare function barcodeGeometry(value: string, opts?: {
+    module?: number;
+    height?: number;
+}): BarcodeGeometry | null;
+
+export { AccountAuth, type AccountAuthClassNames, type AccountAuthMessages, type AccountAuthProps, type AccountAuthView, type AccountFormProps, type AccountMessageKey, type AccountMessages, type AccountStatus, type AccountTextProps, AuthActionData, AuthErrorCode, AuthStep, Barcode, type BarcodeGeometry, type BarcodeProps, InvoiceList, type InvoiceListClassNames, type InvoiceListProps, NextActionBar, type NextActionBarClassNames, type NextActionBarProps, OrderCard, type OrderCardClassNames, type OrderCardProps, OrderLines, type OrderLinesClassNames, type OrderLinesProps, OrderList, type OrderListClassNames, type OrderListProps, OrderProductsStack, OrderProgress, type OrderProgressClassNames, type OrderProgressProps, OrderStatusBadge, type OrderStatusBadgeProps, type OrderTone, PaymentSummary, type PaymentSummaryProps, PendingPaymentCard, type PendingPaymentCardClassNames, type PendingPaymentCardProps, PendingPaymentList, type PendingPaymentListProps, PostPurchaseAccountPrompt, type PostPurchaseAccountPromptClassNames, type PostPurchaseAccountPromptMessages, type PostPurchaseAccountPromptProps, RefundList, type RefundListClassNames, type RefundListProps, ShipmentCard, type ShipmentCardClassNames, type ShipmentCardProps, type ShipmentMapSlotProps, type UseConnectionResult, type UseCustomerOrderOptions, type UseCustomerOrderResult, type UseCustomerOrdersOptions, type UsePendingPaymentsOptions, type VoucherView, accountAuthMessages, accountMessages, barcodeGeometry, barcodeValue, code128Modules, enumText, lineImage, postPurchaseAccountPromptMessages, stageTone, useCustomerOrder, useCustomerOrders, usePendingPayments, voucherOf };