@getmicdrop/venue-calendar 4.3.1 → 4.3.2

package/dist/api/orders.d.ts

@@ -0,0 +1,193 @@
+import { PaymentIntentResponse, CompleteReservationResponse, CancelReservationResponse, CreateOrderResponse, ValidatePaymentRequest, ValidatePaymentResponse, ExtendSessionResponse, SessionStatus, Order } from './types.js';
+/**
+ * Create a payment intent for the cart
+ *
+ * This initiates the Stripe payment flow by creating a PaymentIntent
+ * on the backend. The response includes the client_secret needed
+ * for Stripe Elements.
+ *
+ * @param cartId - The cart/order UUID
+ * @param quantities - Map of ticketId -> quantity
+ * @param donationAmounts - Map of ticketId -> donation amount in dollars (for type=2 tickets)
+ * @returns Payment intent data including client_secret, or null on error
+ */
+/** The buyer, sent ONLY on the $0 finalize call. See createPaymentIntent. */
+export interface FreeOrderBuyer {
+    firstName: string;
+    lastName: string;
+    email: string;
+    /**
+     * The venue's checkout-settings answers. The paid path persists both at
+     * validate-payment-intent, which a $0 order never reaches — so for a free
+     * order this call is the only place they can land.
+     */
+    phone?: string;
+    questionAnswer?: string;
+    mailingList?: boolean;
+}
+export declare function createPaymentIntent(cartId: string, quantities: Record<string | number, number>, donationAmounts?: Record<string | number, number>, buyer?: FreeOrderBuyer, uiLocale?: string): Promise<PaymentIntentResponse | null>;
+/**
+ * Fetch an existing cart by UUID (cross-device pre-fill — §1.3).
+ *
+ * Returns the server's authoritative view of a cart so a second device
+ * visiting the tickets page can see the in-progress reservation it created
+ * on another device. Returns `null` if:
+ *   - the cart no longer exists (404)
+ *   - the cart belongs to a different event than `expectedEventID` (when
+ *     supplied) — we don't want to mix carts across events
+ *   - the cart status is no longer `reserved` / `active` (e.g. expired,
+ *     completed, abandoned) — caller should treat the local cookie as stale
+ *   - any network/decode failure (caller falls back to localStorage only)
+ *
+ * Returned shape matches the orders-service `GET /v2Public/cart/{uuid}`
+ * response: a Cart model with embedded Reservations.
+ */
+export interface CartReservationView {
+    ticketID: number;
+    quantity: number;
+    priceAtReservation: number;
+    status: string;
+}
+/** One gift card already applied to the cart, as the server will describe it. */
+export interface CartGiftCardView {
+    giftCardId: number;
+    /** Last four only — the server never returns the code. Display, not identity. */
+    maskedCode: string;
+    /**
+     * Allocated amount in DOLLARS (the wire carries cents), or null when the
+     * server sent nothing usable — never 0, which would understate coverage.
+     */
+    amount: number | null;
+}
+export interface CartView {
+    uuid: string;
+    eventID: number;
+    status: string;
+    expiresAt: string;
+    reservations: CartReservationView[];
+    giftCards: CartGiftCardView[];
+}
+export declare function getCartByUUID(cartUUID: string, expectedEventID?: string | number): Promise<CartView | null>;
+/**
+ * Update cart quantities after the cart already exists.
+ *
+ * Replaces all reservations on the cart with the new quantities.
+ * The orders-service handler releases old reservations (returning
+ * inventory) and creates new ones (decrementing inventory) atomically.
+ *
+ * Use this when the user changes ticket counts AFTER the initial
+ * cart was created via initiateOrder. The cart UUID is preserved,
+ * so the timer and extension state stay intact.
+ *
+ * @returns true on success, false on failure
+ */
+export declare function updateCartQuantities(cartId: string, quantities: Record<string | number, number>, donationAmounts?: Record<string | number, number>): Promise<boolean>;
+/**
+ * Complete reservation after successful payment
+ *
+ * Called after Stripe confirms the payment to finalize the order
+ * and generate tickets.
+ *
+ * @param orderUuid - The order UUID
+ * @returns Success status and message
+ */
+export declare function completeReservation(orderUuid: string): Promise<CompleteReservationResponse>;
+/**
+ * Cancel reservation and release tickets back to inventory
+ *
+ * Called when user abandons checkout or session expires.
+ *
+ * @param orderUuid - The order UUID
+ * @returns Success status and message
+ */
+export declare function cancelReservation(orderUuid: string): Promise<CancelReservationResponse>;
+/**
+ * Request a refund for a completed order (buyer self-service).
+ *
+ * Public, login-less: the buyer reaches their tickets page from the order UUID in
+ * their confirmation link, so the same UUID authorizes the request. This does NOT
+ * move money — it flags the order (RefundRequested + an optional buyer message)
+ * for the venue/operator to action from their dashboard, exactly as the backend
+ * RequestRefund handler records it. Replaces the "email the venue" dead-end that
+ * was the only way to ask for a refund from the ticket page (MIC-1795).
+ *
+ * @param orderUUID - The order UUID
+ * @param message - Optional note to the venue (why they want a refund)
+ * @returns Success status, with an error message on failure
+ */
+export declare function requestOrderRefund(orderUUID: string, message?: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Create a new order/cart
+ *
+ * This creates an empty order that can be used for checkout.
+ * The order UUID is used for all subsequent operations.
+ *
+ * @param eventId - The event ID
+ * @param promoCode - Optional promo code to apply
+ * @returns The order UUID, or null on error
+ */
+export declare function createOrder(eventId: string | number, promoCode?: string): Promise<CreateOrderResponse | null>;
+/**
+ * Get order details (public, no auth required)
+ *
+ * Fetches the order details for displaying on the success page.
+ *
+ * @param orderId - The order UUID or ID
+ * @returns The order details, or null on error
+ */
+export declare function getOrder(orderId: string): Promise<Order | null>;
+/**
+ * Validate payment intent and complete the order
+ *
+ * This is an alternative to completeReservation that accepts
+ * additional payment details. Used by micdrop-frontend.
+ *
+ * @param cartId - The cart/order UUID
+ * @param payload - Payment validation payload
+ * @returns Validation result
+ */
+export declare function validatePaymentIntent(cartId: string, payload: ValidatePaymentRequest, uiLocale?: string): Promise<ValidatePaymentResponse | null>;
+/**
+ * Extend the checkout session by 15 minutes
+ *
+ * Users get a limited number of extensions (typically 2-3).
+ *
+ * @param orderUuid - The order UUID
+ * @returns Extension result with new expiry time
+ */
+export declare function extendCheckoutSession(orderUuid: string): Promise<ExtendSessionResponse>;
+/**
+ * Get current session status including expiry time
+ *
+ * Used to display countdown timer and check if extensions are available.
+ *
+ * @param orderUuid - The order UUID
+ * @returns Session status including expiry time
+ */
+export declare function getSessionStatus(orderUuid: string): Promise<SessionStatus>;
+/**
+ * Initiate a new order (alias for createOrder)
+ *
+ * This function provides backwards compatibility with micdrop-frontend.
+ * It accepts the same parameters as the legacy initiateOrder function.
+ *
+ * @param cartData - Object containing eventID and optional quantities/promoCode
+ * @returns The order UUID, or null on error
+ */
+export declare function initiateOrder(cartData?: {
+    eventID: string | number;
+    promoCode?: string;
+    quantities?: Record<string | number, number>;
+}): Promise<string | null>;
+/**
+ * Track UTM source for analytics
+ *
+ * Records the traffic source (utm_source parameter) for marketing analytics.
+ *
+ * @param venueId - The venue ID
+ * @returns Promise that resolves when tracking is complete
+ */
+export declare function trackUTMSource(venueId: string | number): Promise<void>;

package/dist/api/promo.d.ts

@@ -0,0 +1,45 @@
+import { PromoValidationResponse } from './types.js';
+/**
+ * Validate a promo code for an event
+ *
+ * Checks if a promo code is valid and returns its effects:
+ * - Discount amount and type
+ * - Hidden ticket reveal
+ *
+ * @param eventId - The event ID
+ * @param code - The promo code to validate
+ * @returns Validation result with discount info
+ */
+export declare function validatePromoCode(eventId: string | number, code: string): Promise<PromoValidationResponse>;
+/**
+ * Check if promo codes are available for an event
+ *
+ * Used to conditionally show/hide the promo code input field.
+ *
+ * @param eventId - The event ID
+ * @returns Whether promo codes exist for this event
+ */
+export declare function hasPromoCodes(eventId: string | number): Promise<boolean>;
+/**
+ * Apply a promo code to a cart
+ *
+ * This updates the cart with the promo code discount.
+ *
+ * @param cartId - The cart UUID
+ * @param code - The promo code to apply
+ * @returns Success status
+ */
+export declare function applyPromoCode(cartId: string, code: string, productQuantities?: Record<string | number, number>): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Remove a promo code from a cart
+ *
+ * @param cartId - The cart UUID
+ * @returns Success status
+ */
+export declare function removePromoCode(cartId: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;

package/dist/api/result.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Result — the canonical error channel for API loaders.
+ *
+ * The public loaders in this package historically collapsed a failed fetch
+ * to an empty value (`[]`, `{ performers: [], showPerformers: false }`, or
+ * `null`), which is indistinguishable from a genuinely empty result. A buyer
+ * hitting a live event during a transient endpoint blip then sees a dead
+ * "No tickets available" button with no retry; a failed calendar month
+ * renders dark, so the venue looks like it has nothing on.
+ *
+ * `Result<T>` gives loaders a typed error channel so callers can tell
+ * "the request failed" apart from "there is genuinely nothing here", and
+ * offer a retry instead of silently degrading. Loaders expose a `*Result`
+ * variant returning this; the array/object-returning public functions stay
+ * as thin fail-open adapters over that variant (single source of truth for
+ * the fetch + validation logic).
+ *
+ * Not to be confused with `ApiResponse<T>` (types.ts) — that is the write-path
+ * HTTP envelope returned by `apiPost`/`apiGet`/etc. (`{ success, data?, error?,
+ * statusCode? }`, discriminated on `.success`). `Result<T>` is the read-path
+ * loader channel, discriminated on `.ok`. They are deliberately separate:
+ * `ApiResponse` carries transport metadata, `Result` carries only "loaded vs
+ * failed". Check `.ok` on a Result, `.success` on an ApiResponse — never mix.
+ */
+export type Result<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    notFound?: boolean;
+};
+/** Wrap a successful value. */
+export declare function ok<T>(data: T): Result<T>;
+/**
+ * Wrap a failure with a short, stable error code (used for i18n/render).
+ *
+ * This is a TRANSIENT failure by default (`notFound` is unset) — the request
+ * couldn't complete (network, timeout, 5xx). Loaders that gate an SSR 404 on a
+ * Result must treat a plain `err(...)` as retryable (503), not "gone" (404), so
+ * a backend blip never renders a permanent-looking 404 to a buyer or crawler.
+ */
+export declare function err(error: string): Result<never>;
+/**
+ * Wrap a genuine "this resource does not exist" failure (upstream 404).
+ *
+ * Distinct from `err(...)`: only this warrants an SSR 404. A transient upstream
+ * failure must NOT collapse to `errNotFound` — that is exactly the bug this
+ * channel exists to prevent (a fetch blip becoming a permanent 404).
+ */
+export declare function errNotFound(error: string): Result<never>;
+/** Narrowing guard — true when the result carries data. */
+export declare function isOk<T>(result: Result<T>): result is {
+    ok: true;
+    data: T;
+};
+/**
+ * Narrowing guard — true when the result is a failure (transient OR not-found).
+ *
+ * This package typechecks with `strictNullChecks` off, where the ELSE flow of a
+ * discriminated union does NOT narrow (`if (r.ok) {…}` narrows the positive
+ * branch, but the fall-through keeps the full union). Consumers that need the
+ * failure branch's `error`/`notFound` must narrow POSITIVELY through this guard
+ * rather than relying on `!r.ok` control flow.
+ */
+export declare function isErr<T>(result: Result<T>): result is {
+    ok: false;
+    error: string;
+    notFound?: boolean;
+};
+/**
+ * Collapse a Result to its data, substituting `fallback` on failure.
+ *
+ * This is the fail-open bridge the legacy array/object-returning loaders use
+ * so existing callers keep their current "degrade to empty" behaviour until
+ * they adopt the Result variant and render an error/retry state.
+ */
+export declare function unwrapOr<T>(result: Result<T>, fallback: T): T;

package/dist/api/route-manifest.d.ts

@@ -0,0 +1,206 @@
+/**
+ * The wire contract: every backend route this repo names.
+ *
+ * A test that asserts a route NAME proves nothing unless it proves the name
+ * RESOLVES. `expect(fetch).toHaveBeenCalledWith('/api/…')` passes happily
+ * against a route the router 404s — that is how 4.0.96 shipped a POST against a
+ * route the backend did not serve and locked every buyer out of every
+ * password-protected event.
+ *
+ * This module is the single source of truth two gates read:
+ *
+ *   route-answers-contract.test.ts  (every PR, offline)
+ *     every API call site in src/ must name a route listed here, with a verb
+ *     and body shape that match.
+ *
+ *   route-answers-probe.test.ts     (CI job, hits the deployed backend)
+ *     every route listed here must be ANSWERED by the router. That is what
+ *     keeps this file from being fiction.
+ *
+ * ROUTER-404 vs RESOURCE-404 — the whole diagnosis. The backend replies to an
+ * unrouted request with a 404 whose SHAPE depends on which host answered: the
+ * public host names it back (`{"code":"NOT_FOUND","message":"Route not found:
+ * POST /api/…"}`), the orders-v2 host answers a generic `{"code":"NOT_FOUND",
+ * "message":"Not Found"}` (#808). A route that EXISTS but whose resource does
+ * not replies 400 "Invalid event ID", or 404 "Order not found" / CART_NOT_FOUND,
+ * or 401, or 200 — a RESOURCE-level answer. `isRouterNotFound()` below is the one
+ * place that distinction is made, per-host.
+ *
+ * PROBE SAFETY. The probe test asks PRODUCTION. A probe recipe is only correct if
+ * it CANNOT MUTATE — and that claim is worthless unless something checks it. It
+ * is load-bearing, not decorative: `POST /orders/create` with an EMPTY body
+ * answers 200 and creates a real order.
+ *
+ * So every mutating row (POST/PUT/DELETE) must declare `probe.safety`, and
+ * route-answers-probe.test.ts asserts the declaration against what production
+ * actually answers. That holds for EVERY mutating row in BOTH lists — an UNSERVED
+ * row is not exempt. "It is a router-404, so no handler runs" is circular: it is
+ * true until the day the row's whole purpose is fulfilled and the backend ships the
+ * route. The probe sends the request BEFORE it can know whether the name resolved,
+ * so on that day the POST lands on a live handler, and the safety claim is the only
+ * thing asserting it bounced. Two shapes are legal, and only two:
+ *
+ *   refused — the handler REJECTS the recipe (400 invalid id, 401, 404, 422) and
+ *             never reaches its write. Assert the status is one it declared.
+ *
+ *   inert   — the handler ACCEPTS the recipe but it targets a resource that
+ *             cannot exist, so it changes nothing, and the response SAYS SO.
+ *             `POST /orders/complete/:uuid` is a bulk update keyed on the UUID:
+ *             it answers 200 "Completed 0 reservations" for every UUID, refusing
+ *             nothing — there is no rejecting recipe to write. Assert the row
+ *             count in the body: the response itself proves zero rows moved.
+ *
+ * A row that cannot honestly claim either shape must not be probed at all.
+ */
+/** Host prefixes. `client.ts` prefixes any endpoint not starting with `http`
+ *  with PUBLIC — a bare `/orders/create` means `${PUBLIC}/orders/create`. */
+export declare const PUBLIC = "/api/v2/public";
+export declare const ORDERS_V2 = "/api/orders/v2/public";
+export declare const ORDERS_V2_ROOT = "/api/orders/v2";
+/**
+ * The verbs this contract knows — runtime, not just a type. The source scanner in
+ * route-answers-contract.test.ts checks a call site's `method:` against THIS list
+ * and goes red on anything else. When the scanner carried its own regex
+ * alternation instead, a `method: 'PATCH'` matched nothing, fell through to the
+ * `'GET'` default and was checked against the GET row: green, silently, at a route
+ * that serves no PATCH. One list, read by both.
+ */
+export declare const HTTP_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE"];
+export type HttpMethod = (typeof HTTP_METHODS)[number];
+/** Whether a verb written at a call site is one this contract can reason about. */
+export declare function isHttpMethod(verb: string): verb is HttpMethod;
+/**
+ * Why a probe cannot mutate production — see PROBE SAFETY above. Required on
+ * every POST/PUT/DELETE row and asserted live; the offline gate fails a mutating
+ * row that omits it, so the safety claim can never again be author discipline.
+ */
+export type ProbeSafety = {
+    kind: 'refused';
+    /** Statuses the handler answers when it refuses this recipe. Never 2xx. */
+    statuses: readonly number[];
+} | {
+    kind: 'inert';
+    /** The status the handler answers when it accepts this recipe. */
+    status: number;
+    /** Must match the response body, and must prove nothing was written. */
+    proof: RegExp;
+    /** Why accepting it changes nothing. */
+    why: string;
+};
+export interface Probe {
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** Required on POST/PUT/DELETE. Reads cannot mutate, so GET/HEAD omit it. */
+    safety?: ProbeSafety;
+}
+export interface BackendRoute {
+    method: HttpMethod;
+    /** Full path from the host root. Path params are written `:name`. */
+    path: string;
+    /** Whether the route takes a request body. */
+    body: 'required' | 'none';
+    /** A request that reaches the router and cannot change anything behind it. */
+    probe: Probe;
+}
+/** The verbs that can write. These are the probes that need a safety claim. */
+export declare function isMutating(method: HttpMethod): boolean;
+/** Turn a manifest pattern into a matcher: `:name` matches any single segment. */
+export declare function patternMatches(pattern: string, concrete: string): boolean;
+/**
+ * A path param value that is syntactically valid and cannot exist.
+ *
+ * Exported because production code needs it too: `testNetworkConnection()` asks a
+ * SERVED route about this id to find out whether the router answers at all. Same
+ * id, same reason, one definition — an id-that-cannot-exist written out twice is
+ * two ids that can drift.
+ */
+export declare const NONEXISTENT_ID = "00000000-0000-0000-0000-000000000000";
+/**
+ * Routes the deployed backend ANSWERS. Verified by route-answers-probe.test.ts.
+ * Adding a row here without the probe agreeing is exactly the lie this gate exists
+ * to catch — the probe will fail the row.
+ */
+export declare const SERVED_ROUTES: BackendRoute[];
+export interface UnservedRoute extends Omit<BackendRoute, 'body'> {
+    /** Where the dead name is spoken. */
+    callSites: string[];
+    /** What the buyer sees because the name resolves to nothing. */
+    impact: string;
+    issue: string;
+}
+/**
+ * Routes this repo NAMES that the router does not serve — verified router-404.
+ *
+ * This is a debt ledger, not a sanctioned end-state. It exists so the gate can
+ * land red-free while every dead name stays visible and non-regressible: the
+ * contract test fails if a NEW call site names a route in neither list, and the
+ * probe fails if a route listed here starts answering (fix the call site, then
+ * move the row into SERVED_ROUTES). The list may only ever shrink.
+ */
+export declare const UNSERVED_ROUTES: UnservedRoute[];
+export interface RetiredRoute {
+    method: HttpMethod;
+    /** The dead name, exactly as the ledger row used to spell it. */
+    path: string;
+    /** Who used to speak it, and what happened to them. */
+    wasNamedBy: string;
+    issue: string;
+}
+/**
+ * Dead names this repo has STOPPED speaking. The ledger's graveyard.
+ *
+ * UNSERVED_ROUTES says "may only ever shrink" — and until now nothing enforced
+ * that. Two ways to put a dead name back were wide open: re-add the row, or write
+ * a fresh call site and baseline it. Either one turns the debt ledger into a
+ * silencer, and a silencer is how the 4.0.96 password outage shipped in the first
+ * place.
+ *
+ * So a retired route is retired in both directions, asserted in
+ * route-answers-contract.test.ts:
+ *
+ *   - nothing in src/ may NAME it again (a new call site goes red, not baselined);
+ *   - it may not reappear in UNSERVED_ROUTES (you cannot re-open the debt);
+ *   - it may not appear in SERVED_ROUTES either — if the backend genuinely ships
+ *     the route one day, DELETE the row here in the same commit that adds the
+ *     served one with a probe recipe proving the router answers it. That is a
+ *     deliberate two-place edit, which is the whole point: coming back from the
+ *     dead should cost more than adding a line.
+ */
+export declare const RETIRED_ROUTES: RetiredRoute[];
+/**
+ * The router-404 discriminator — the one place the distinction is made.
+ *
+ * TRUE  = the name resolved to nothing (the bug), per the answering HOST's
+ *         unrouted-name shape.
+ * FALSE = the router answered; whatever the handler then said (400 invalid id,
+ *         404 "Order not found", 401, 501, 200) is a RESOURCE-level answer and
+ *         is none of this gate's business — OR the path belongs to a host this
+ *         manifest does not know, in which case no router-404 can be claimed and
+ *         `hostsToCanary` is what fails closed on it.
+ *
+ * Takes the PATH, not just the body: the orders-v2 and public hosts answer a
+ * dead name with different bodies, so the body alone cannot be read without
+ * knowing which host produced it (#808).
+ */
+export declare function isRouterNotFound(status: number, bodyText: string, path: string): boolean;
+export interface CanaryHost {
+    /** Host label, for the canary's failure message. */
+    label: string;
+    /** A path under this host that no route serves — to probe its 404 shape. */
+    deadPath: (_nonce: string) => string;
+}
+/**
+ * The distinct hosts a set of probe paths touches, each with a dead-route path
+ * builder — so the canary can prove the discriminator works on EVERY host the
+ * manifest probes, derived from the rows rather than hardcoded, so a host added
+ * later cannot get a free pass (#808).
+ *
+ * FAILS CLOSED: a probe path that belongs to no known host throws here, because
+ * the discriminator cannot tell a dead name from a live one on a host whose 404
+ * shape it has never been taught. A new host prefix must be added to HOSTS (with
+ * its router-404 discriminator) before its rows can be trusted.
+ */
+export declare function hostsToCanary(paths: readonly string[]): CanaryHost[];
+/** HEAD is answered by the GET route — Express routes the two together. */
+export declare function effectiveMethod(method: HttpMethod): HttpMethod;

package/dist/api/transformers/address.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Address helpers — shared between the event, series and collection page
+ * transformers.
+ *
+ * Lifted verbatim from public-calendar-flow/transform.ts so the series and
+ * collection canonicals (and the in-place transformApiEvent) read a single
+ * source instead of each carrying a private copy. Behavior is byte-identical
+ * to the previous module-private versions.
+ */
+/**
+ * Parse a single-line address string into display lines.
+ * E.g. "123 Main St, Los Angeles, CA 90012" -> ["123 Main St", "Los Angeles, CA 90012"]
+ */
+export declare function parseAddress(addressStr: string): string[];
+/**
+ * Build a Google Maps search URL from an address string.
+ */
+export declare function buildGoogleMapsUrl(address: string): string;

package/dist/api/transformers/cart.d.ts

@@ -0,0 +1,34 @@
+import { CartView, CartReservationView, CartGiftCardView } from '../orders.js';
+/**
+ * Parse a single raw reservation row into the normalized CartReservationView.
+ *
+ * Wire shape is contained here. Uses `??` (PascalCase first, camelCase
+ * fallback) so a real `0` quantity / price is preserved. Numeric coercion via
+ * Number(), status via String() -- byte-identical to the inline `.map` in
+ * getCartByUUID.
+ */
+export declare function parseCartReservation(raw: unknown): CartReservationView;
+/**
+ * Parse one applied gift card.
+ *
+ * `maskedCode` is all the server will say — the code itself is a bearer
+ * instrument and this cart endpoint is public, keyed only by the cart UUID — so
+ * removal is keyed by `giftCardId`. `amount` arrives in CENTS (the orders-service
+ * column) and is converted to DOLLARS here, because every gift-card figure the
+ * checkout UI handles downstream is in dollars.
+ *
+ * A missing or malformed amount parses to `null`, never 0. This value is what
+ * the panel says a card COVERS; a fabricated $0 would understate coverage and
+ * feed a wrong order ceiling back into the checkout. The consumer drops such an
+ * entry instead of drawing it (mf#2383).
+ */
+export declare function parseCartGiftCard(raw: unknown): CartGiftCardView;
+/**
+ * Parse a raw cart payload into the normalized CartView domain shape.
+ *
+ * Wire shape (RawCart) is contained inside this module and never escapes it.
+ * Reconciles PascalCase and camelCase JSON tags via `??`. Reservations are
+ * normalized through parseCartReservation. Byte-identical to the inline
+ * normalization previously embedded in getCartByUUID.
+ */
+export declare function parseCart(raw: unknown): CartView;

package/dist/api/transformers/collection.d.ts

@@ -0,0 +1,12 @@
+import { PublicCollectionData } from '../types.js';
+import { EventData } from '../../public-calendar-flow/types';
+/**
+ * Transform PublicCollectionData (from the collection API) into our clean EventData interface.
+ * Sets collectionId so EventExperience renders in full-width collection mode.
+ */
+export declare function parseCollection(collection: PublicCollectionData): EventData;
+/**
+ * Back-compat alias — the public-calendar-flow shaper name. Existing call
+ * sites importing transformCollectionData continue to work unchanged.
+ */
+export declare const transformCollectionData: typeof parseCollection;