@getmicdrop/venue-calendar 4.0.110 → 4.0.112

package/dist/api/api/gift-cards.d.ts

@@ -1,108 +0,0 @@
-import { VenueId } from '@getmicdrop/svelte-components';
-import { Result } from './result.js';
-/**
- * Request payload for creating a gift card purchase
- */
-export interface GiftCardPurchaseRequest {
-    venueId: number | VenueId;
-    amount: number;
-    recipientEmail: string;
-    recipientName: string;
-    personalMessage?: string;
-    purchaserEmail: string;
-    purchaserName: string;
-    scheduledDeliveryAt?: string | null;
-}
-/**
- * Response from gift card purchase creation
- */
-export interface GiftCardPurchaseResponse {
-    giftCardUUID: string;
-    clientSecret: string;
-    amount: number;
-    stripePublishableKey: string;
-}
-/**
- * Venue information needed for gift card purchase
- */
-export interface VenueInfo {
-    id: VenueId;
-    name: string;
-    slug: string;
-    stripePublishableKey?: string;
-}
-/**
- * Create a gift card purchase and get Stripe client secret
- * @param req - Gift card purchase request details
- * @returns Gift card UUID and Stripe client secret, or null on failure
- */
-export declare function createGiftCardPurchase(req: GiftCardPurchaseRequest): Promise<GiftCardPurchaseResponse | null>;
-/**
- * Result shape consumed by the Checkout component / GiftCardInput.
- * Monetary fields here are in DOLLARS (formatCurrency-ready).
- */
-export interface ApplyGiftCardResult {
-    valid: boolean;
-    giftCardCode?: string;
-    giftCardAmount?: number;
-    giftCardBalance?: number;
-    paymentType?: string;
-    stripeAmount?: number;
-    orderTotal?: number;
-    requiresStripe?: boolean;
-    error?: string;
-}
-/**
- * Apply a gift card to a cart.
- */
-export declare function applyGiftCard(cartId: string, code: string): Promise<ApplyGiftCardResult>;
-export interface RemoveGiftCardResult {
-    success: boolean;
-    error?: string;
-}
-/**
- * Remove a gift card from a cart. Pass a `code` to remove a single stacked card;
- * omit it to remove all applied gift cards.
- */
-export declare function removeGiftCard(cartId: string, code?: string): Promise<RemoveGiftCardResult>;
-export interface CompleteGiftCardPaymentInput {
-    firstName: string;
-    lastName: string;
-    email: string;
-    phoneNumber?: string | null;
-    mailingList?: boolean;
-}
-export interface CompleteGiftCardPaymentResult {
-    success: boolean;
-    orderId?: string;
-    confirmationNumber?: string;
-    error?: string;
-}
-/**
- * Complete a gift-card-only payment (no Stripe required when balance >= total).
- */
-export declare function completeGiftCardPayment(cartId: string, customerDetails: CompleteGiftCardPaymentInput): Promise<CompleteGiftCardPaymentResult>;
-/**
- * Fetch venue information by slug, discriminating a real 404 from a transient
- * failure.
- *
- * The gift-card SSR loader (`v/[venueSlug]/gift-cards/purchase/+page.ts`) gates
- * its HTTP status on this: only an upstream 404 (`errNotFound`) becomes a page
- * 404. A 5xx, network error, or timeout is `err(...)` (transient) so the loader
- * answers 503/retry rather than a permanent-looking 404 on a backend blip.
- *
- * @param slug - Venue slug
- * @param customFetch - Optional custom fetch function (for SSR)
- * @returns `ok(venue)`, `errNotFound(...)` for a real 404, or `err(...)` transient
- */
-export declare function getVenueBySlugResult(slug: string, customFetch?: typeof fetch): Promise<Result<VenueInfo>>;
-/**
- * Fetch venue information by slug
- *
- * Fail-open adapter over {@link getVenueBySlugResult}: returns `null` on any
- * failure. SSR loaders that need 404-vs-503 use the Result variant.
- *
- * @param slug - Venue slug
- * @returns Venue info or null on failure
- */
-export declare function getVenueBySlug(slug: string, customFetch?: typeof fetch): Promise<VenueInfo | null>;

package/dist/api/api/index.d.ts

@@ -1,46 +0,0 @@
-/**
- * MicDrop Public Checkout API
- *
- * This module provides a complete API layer for the public checkout flow:
- * - Order creation and management
- * - Payment processing with Stripe
- * - Promo code validation
- * - Event and venue data fetching
- * - Session management
- *
- * All endpoints are public (no authentication required) and use
- * the /api/v2/public base path.
- *
- * @example
- * ```typescript
- * import {
- *   createPaymentIntent,
- *   validatePromoCode,
- *   transformOrder,
- * } from '@getmicdrop/venue-calendar/api';
- *
- * // Create payment intent
- * const intent = await createPaymentIntent(cartId, { 123: 2 });
- *
- * // Validate promo code
- * const promo = await validatePromoCode(eventId, 'DISCOUNT10');
- *
- * // Transform order for display
- * const order = transformOrder(apiResponse);
- * ```
- */
-export { configureApi, getApiConfig, getPublicBaseUrl, getLegacyPublicUrl, getOrdersV2Url, getClientIP, apiGet, apiPost, apiPut, apiDelete, } from './client.js';
-export { createPaymentIntent, validatePaymentIntent, updateCartQuantities, getCartByUUID, createOrder, getOrder, completeReservation, cancelReservation, extendCheckoutSession, getSessionStatus, initiateOrder, trackUTMSource, } from './orders.js';
-export type { CartReservationView, CartView } from './orders.js';
-export { validatePromoCode, hasPromoCodes, applyPromoCode, removePromoCode, } from './promo.js';
-export { fetchEventDetails, fetchEventTickets, fetchEventPerformers, fetchAllVenues, fetchVenueEvents, getMonthEvents, getOrgMonthEvents, getSeriesOccurrences, fetchSeriesOccurrences, fetchPublicCollection, resolvePublicEntity, checkEventPassword, checkCollectionPassword, testNetworkConnection, fetchEventDetailsResult, fetchEventTicketsResult, fetchEventPerformersResult, fetchAllVenuesResult, fetchVenueEventsResult, getMonthEventsResult, getOrgMonthEventsResult, getSeriesOccurrencesResult, fetchSeriesOccurrencesResult, } from './events.js';
-export { ok, err, errNotFound, isOk, isErr, unwrapOr, type Result, } from './result.js';
-export { getVenue, getVenueFees, getVenueBySlug } from './venues.js';
-export { createGiftCardPurchase, applyGiftCard, removeGiftCard, completeGiftCardPayment, } from './gift-cards.js';
-export type { GiftCardPurchaseRequest, GiftCardPurchaseResponse, ApplyGiftCardResult, RemoveGiftCardResult, CompleteGiftCardPaymentInput, CompleteGiftCardPaymentResult, } from './gift-cards.js';
-export { joinWaitlist, getWaitlistStatus, validateWaitlistToken, } from './waitlist.js';
-export type { JoinWaitlistResult, WaitlistStatusResult, ValidateWaitlistTokenResult, } from './waitlist.js';
-export { computeCtaState } from './cta.js';
-export type { CtaState, CtaStateOptions } from './cta.js';
-export { transformOrder, transformTicket, transformOrderForDisplay, transformEvent, transformEventData, transformAvailableTicket, getCDNImageUrl, getEventImageUrl, calculateCtaState, transformVenue, extractVenueFees, formatVenueAddress, } from './transformers/index.js';
-export type { ApiConfig, ApiResponse, PaymentIntentRequest, PaymentIntentResponse, CompleteReservationResponse, CancelReservationResponse, CreateOrderRequest, CreateOrderResponse, ValidatePaymentRequest, ValidatePaymentResponse, AttendeeInfo, ExtendSessionRequest, ExtendSessionResponse, SessionStatus, PromoValidationResponse, HasPromoCodesResponse, Order, PurchasedTicket, Event, AvailableTicket, EventPerformersResponse, Performer, Venue, SeriesOccurrence, SeriesOccurrencesResponse, SeriesPageData, PublicCollectionData, } from './types.js';

package/dist/api/api/orders.d.ts

@@ -1,149 +0,0 @@
-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
- */
-export declare function createPaymentIntent(cartId: string, quantities: Record<string | number, number>, donationAmounts?: Record<string | number, number>): 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;
-}
-export interface CartView {
-    uuid: string;
-    eventID: number;
-    status: string;
-    expiresAt: string;
-    reservations: CartReservationView[];
-}
-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>;
-/**
- * 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): 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/api/promo.d.ts

@@ -1,45 +0,0 @@
-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): 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/api/result.d.ts

@@ -1,78 +0,0 @@
-/**
- * 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/api/route-manifest.d.ts

@@ -1,179 +0,0 @@
-/**
- * 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 404 + `{"error":{"code":"NOT_FOUND","message":"Route
- * not found: POST /api/…"}}`. A route that EXISTS but whose resource does not
- * replies 400 "Invalid event ID", or 404 "Order not found", or 401, or 200.
- * Only the "Route not found:" prefix means the name resolved to nothing.
- * `isRouterNotFound()` below is the one place that distinction is made.
- *
- * 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).
- * 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.
- */
-export declare function isRouterNotFound(status: number, bodyText: string): boolean;
-/** HEAD is answered by the GET route — Express routes the two together. */
-export declare function effectiveMethod(method: HttpMethod): HttpMethod;

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

@@ -1,18 +0,0 @@
-/**
- * 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/api/transformers/cart.d.ts

@@ -1,19 +0,0 @@
-import { CartView, CartReservationView } 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 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/api/transformers/collection.d.ts

@@ -1,12 +0,0 @@
-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;