@getmicdrop/venue-calendar 4.0.112 → 4.0.113

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

@@ -0,0 +1,179 @@
+/**
+ * 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

@@ -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/api/transformers/cart.d.ts

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

@@ -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;

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

@@ -0,0 +1,173 @@
+import { Event, AvailableTicket } from '../types.js';
+interface ApiEvent {
+    eventID?: number;
+    id?: number;
+    ID?: number;
+    name?: string;
+    title?: string;
+    slug?: string;
+    description?: string;
+    date?: string;
+    startDateTime?: string;
+    start_date_time?: string;
+    endDateTime?: string;
+    end_date_time?: string;
+    doorsOpenTime?: string;
+    doors_open_time?: string;
+    timezone?: string;
+    time_zone?: string;
+    venueId?: number;
+    venue_id?: number;
+    venueName?: string;
+    venue_name?: string;
+    venueAddress?: string;
+    venue_address?: string;
+    location?: string;
+    imageUrl?: string;
+    imageURL?: string;
+    image_url?: string;
+    image?: string;
+    status?: string;
+    isPublished?: boolean;
+    is_published?: boolean;
+    isCancelled?: boolean;
+    is_cancelled?: boolean;
+    availableTickets?: any[];
+    available_tickets?: any[];
+    tickets?: any[];
+    ticketsAvailable?: number;
+    tickets_available?: number;
+    ticketsSold?: number;
+    tickets_sold?: number;
+    minPrice?: number;
+    min_price?: number;
+    maxPrice?: number;
+    max_price?: number;
+    ctaText?: string;
+    cta_text?: string;
+    ctaState?: string;
+    cta_state?: string;
+    showPerformers?: boolean;
+    show_performers?: boolean;
+    eventSeriesId?: number;
+    event_series_id?: number;
+    seriesInstanceNumber?: number;
+    series_instance_number?: number;
+    timeZone?: string;
+    eventSummary?: string;
+    password?: string;
+    hasPassword?: boolean;
+    disclaimer?: string;
+    ticketType?: number;
+    eventTicketingType?: number;
+    ageRestriction?: number;
+    displayAgeRestriction?: boolean;
+    displayStartTime?: boolean;
+    displayEndTime?: boolean;
+    displayDoorsTime?: boolean;
+    collectionId?: number;
+    collection_id?: number;
+    ticketsRemaining?: number;
+    ticketsTotal?: number;
+    hasHiddenTickets?: boolean;
+    stage?: {
+        name?: string;
+    } | null;
+    stageName?: string;
+    stageId?: number;
+    eventCategoryTypes?: number[] | null;
+    publicPerformers?: Array<{
+        id?: number;
+        displayName?: string;
+        image?: string;
+    }> | null;
+    collectionIds?: number[] | null;
+    venue?: Record<string, any>;
+    performers?: Record<string, any>[];
+    faqs?: Record<string, any>[];
+    showtimes?: Record<string, any>[];
+    purchasedTickets?: Record<string, any>[];
+}
+/**
+ * Get CDN image URL.
+ *
+ * Delegates the host-join to SC's canonical `resolveImageUrl` (one path-join,
+ * one host constant). `{ cdn: true }` picks the Cloudflare-fronted CDN base
+ * (`moxy.sfo3.cdn`), the correct, edge-cached host for public buyer surfaces.
+ *
+ * This replaced VC's local `micdrop-images.sfo3` bucket, which 404s for real
+ * event/venue keys (CDN census 2026-07-05, ledger vc-getcdnimageurl-wrong-
+ * bucket-404). SC additionally passes `data:`/`blob:` URLs through untouched
+ * and normalizes a missing leading slash — a strict superset of the old body.
+ */
+export declare function getCDNImageUrl(path: string | undefined): string;
+/**
+ * Extract image URL from event with fallbacks.
+ *
+ * DIVERGENCE (no-shadowed-helper rename-keep): the HOST-JOIN is now the SC
+ * canonical (via `getCDNImageUrl` above); only the FIELD PRECEDENCE stays local
+ * and deliberately differs -- this transformer reads
+ * `imageUrl -> imageURL -> image_url -> image` (incl. the camelCase `imageURL`,
+ * asserted by event.test.ts), whereas SC reads
+ * `image -> coverImage -> imageUrl -> image_url`. The VC chain is what this
+ * wire boundary trusts; changing it would repoint which field wins for the same
+ * event, so it is preserved. Declared under a non-shadowing name and
+ * re-exported below as `getEventImageUrl` so call sites keep their existing
+ * import -- satisfies `micdrop/no-shadowed-helper` without suppression.
+ */
+declare function getEventImageUrlByFieldPrecedence(apiEvent: ApiEvent): string;
+export { getEventImageUrlByFieldPrecedence as getEventImageUrl };
+/**
+ * Calculate CTA state based on ticket availability
+ */
+/**
+ * VC's 4-state CTA derivation (available/sold_out/coming_soon/ended) for parsed events.
+ * Distinct from SC's `calculateCtaState` (richer wire-level canonical) — renamed to
+ * avoid shadowing the SC export; this variant reads the parsed/raw event shape parseEvent consumes.
+ */
+type CtaState = 'available' | 'sold_out' | 'coming_soon' | 'ended';
+export declare function deriveEventCtaState(apiEvent: ApiEvent): CtaState;
+/**
+ * Parse a raw ticket payload into the normalized AvailableTicket domain shape.
+ *
+ * Wire shape is contained inside this module. Uses `||` chains matching the
+ * old transformer exactly -- 0/false values fall through to the next variant
+ * or default, byte-identical to previous behavior.
+ */
+export declare function parseTicket(raw: unknown): AvailableTicket;
+/**
+ * Parse a raw event payload into the normalized Event domain shape.
+ *
+ * Wire shape (ApiEvent) is contained inside this module and never escapes it.
+ * Uses `||` chains matching the old transformer exactly -- 0/false values fall
+ * through to the next variant, byte-identical to previous behavior. Throw
+ * behavior preserved from old mapper: null/undefined input (property access on a nullish value) or a non-array
+ * tickets field throws exactly as the old code did. Callers always pass real
+ * wire objects.
+ *
+ * COMPOSITION NOTE — passthrough seams (events convergence):
+ * The trailing block of fields below is carried VERBATIM from the wire (no
+ * fallback chains, no normalization) so that the view-shape projections —
+ * `utils/event-transform.js` (DETAIL/BROWSE) and
+ * `public-calendar-flow/transform.ts` (EventData) — can compose parseEvent
+ * for every event-level scalar instead of reading the wire themselves.
+ * `venue`/`performers`/`faqs`/`showtimes`/`purchasedTickets` stay raw objects
+ * by contract: their consumers (and #260's performer canonical) own that
+ * variance; normalizing them here would change rendered output.
+ */
+export declare function parseEvent(raw: unknown): Event;
+/**
+ * Back-compat alias -- existing call sites using transformTicket continue
+ * to work unchanged.
+ */
+export declare const transformTicket: typeof parseTicket;
+/**
+ * Back-compat alias -- existing call sites using transformEvent(apiEvent)
+ * continue to work unchanged.
+ */
+export declare const transformEvent: typeof parseEvent;
+/**
+ * Legacy transformer name for backwards compatibility.
+ */
+export declare const transformEventData: typeof parseEvent;
+export declare function parseEventList(raws: unknown[]): Event[];

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

@@ -0,0 +1,11 @@
+import { ApplyGiftCardResult } from '../gift-cards.js';
+/**
+ * Parse a successful apply-gift-card backend payload into ApplyGiftCardResult.
+ *
+ * Maps the real backend contract to what the Checkout component expects:
+ *   - appliedAmount (cents) -> giftCardAmount (dollars)
+ *   - remainingTotal (dollars) -> stripeAmount (dollars, residual to charge)
+ *   - fullyCoveredByCard -> paymentType 'gift_card_only' | 'split' + requiresStripe
+ * Byte-identical to the inline success-path mapping previously in applyGiftCard.
+ */
+export declare function parseGiftCardApplication(raw: unknown): ApplyGiftCardResult;

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

@@ -0,0 +1,27 @@
+/**
+ * Transformers Index
+ *
+ * Re-exports all transformer functions for convenient importing.
+ *
+ * Canonical parse<Entity> functions (preferred for new code):
+ *   parseEvent, parseVenue, parseOrder, parsePurchasedTicket, parseTicket,
+ *   parseSeries, parseCollection
+ *
+ * Back-compat aliases (old names, call the same function):
+ *   transformEvent, transformEventData, transformVenue, transformOrder,
+ *   transformTicket, transformSeriesPageData, transformCollectionData
+ */
+export { parseOrder, parsePurchasedTicket, transformOrder, // back-compat alias
+transformTicket, // back-compat alias
+transformOrderForDisplay, } from './order.js';
+export { parseEvent, parseEventList, parseTicket, transformEvent, // back-compat alias
+transformEventData, // legacy alias
+transformTicket as transformAvailableTicket, // back-compat alias
+getCDNImageUrl, getEventImageUrl, deriveEventCtaState, deriveEventCtaState as calculateCtaState, } from './event.js';
+export { parseVenue, transformVenue, // back-compat alias
+extractVenueFees, formatVenueAddress, } from './venue.js';
+export { parseSeries, transformSeriesPageData, } from './series.js';
+export { parseCollection, transformCollectionData, } from './collection.js';
+export { parseCart, parseCartReservation } from './cart.js';
+export { parseGiftCardApplication } from './giftCard.js';
+export { parseEventPerformers } from './performer.js';

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

@@ -0,0 +1,44 @@
+import { Order, PurchasedTicket } from '../types.js';
+/**
+ * Parse a raw purchased-ticket payload into the normalized PurchasedTicket domain shape.
+ *
+ * Wire shape (ApiTicket) is contained inside this module. Uses `||` chains matching
+ * the old transformer exactly -- byte-identical to previous behavior. Throw behavior
+ * preserved from old mapper: null/undefined input (property access on a nullish value) throws as the old code did.
+ */
+export declare function parsePurchasedTicket(raw: unknown): PurchasedTicket;
+/**
+ * Parse a raw order payload into the normalized Order domain shape.
+ *
+ * Wire shape (ApiOrder) is contained inside this module and never escapes it.
+ * Uses `||` chains matching the old transformer exactly (all money fields use `||`,
+ * not `??` -- 0-valued amounts fall through to next variant, same as old) --
+ * byte-identical to previous behavior. Throw behavior preserved from old mapper:
+ * null/undefined input (property access on a nullish value) or a non-array tickets field throws as the old code did.
+ */
+export declare function parseOrder(raw: unknown): Order;
+/**
+ * Back-compat alias -- existing call sites using transformTicket continue
+ * to work unchanged.
+ */
+export declare const transformTicket: typeof parsePurchasedTicket;
+/**
+ * Back-compat alias -- existing call sites using transformOrder(apiOrder)
+ * continue to work unchanged.
+ */
+export declare const transformOrder: typeof parseOrder;
+/**
+ * Transform order for display on success page.
+ *
+ * Returns a simplified object with display-ready values.
+ */
+export declare function transformOrderForDisplay(raw: unknown): {
+    orderId: string;
+    displayOrderId: string;
+    email: string;
+    customerName: string;
+    total: number;
+    formattedTotal: string;
+    ticketCount: number;
+    status: string;
+};

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

@@ -0,0 +1,8 @@
+import { EventPerformersResponse } from '../types.js';
+/**
+ * Parse a raw performers payload into the normalized EventPerformersResponse.
+ *
+ * `performers` is coerced to an array (Array.isArray gate), `showPerformers`
+ * to a strict boolean (`=== true`) -- matching fetchEventPerformers exactly.
+ */
+export declare function parseEventPerformers(raw: unknown): EventPerformersResponse;

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

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

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

@@ -0,0 +1,39 @@
+import { Venue } from '../types.js';
+/**
+ * Parse a raw venue payload into the normalized Venue domain shape.
+ *
+ * Wire shape (ApiVenue) is contained inside this module and never escapes it.
+ * Uses `||` / `??` chains matching the old transformer exactly -- byte-identical
+ * to previous behavior. Throw behavior preserved from old mapper: null/undefined
+ * input throws exactly as the old code did. Callers always pass real wire objects.
+ */
+declare function vcParseVenue(raw: unknown): Venue;
+/**
+ * Public re-export under the canonical name + back-compat alias. Existing call
+ * sites using either parseVenue(apiVenue) or transformVenue(apiVenue) continue
+ * to work unchanged; re-exports don't redeclare the identifier so the
+ * no-shadowed-helper rule is satisfied without a suppression.
+ */
+export { vcParseVenue as parseVenue };
+export declare const transformVenue: typeof vcParseVenue;
+/**
+ * Extract fee configuration from a raw venue payload.
+ *
+ * Uses `??` (not `||`) so 0-valued fees are preserved correctly.
+ */
+declare function vcExtractVenueFees(raw: unknown): {
+    serviceFeePercentage: number;
+    serviceFeeCents: number;
+    taxPercentage: number;
+};
+/**
+ * Get formatted venue address.
+ *
+ * Compare-first vs SC canonical formatVenueAddress(venue: Pick<ParsedVenue,
+ * 'address'|'city'|'state'|...>): GENUINELY DIVERGED — VC takes its own `Venue`
+ * domain type (the resolved shape `vcParseVenue` emits), not SC's `ParsedVenue`
+ * pick. Kept local under a non-shadowing name and re-exported below; no
+ * eslint-disable.
+ */
+declare function vcFormatVenueAddress(venue: Venue): string;
+export { vcExtractVenueFees as extractVenueFees, vcFormatVenueAddress as formatVenueAddress, };

package/dist/api/api/venues.d.ts

@@ -0,0 +1,33 @@
+import { Venue } from './types.js';
+/**
+ * Get venue details (public, no auth required)
+ *
+ * Fetches venue information including service fees and taxes
+ * needed for checkout calculations.
+ *
+ * @param venueId - The venue ID
+ * @returns Venue details or null on error
+ */
+export declare function getVenue(venueId: string | number): Promise<Venue | null>;
+/**
+ * Get venue service fee configuration
+ *
+ * Returns just the fee-related fields for checkout calculations.
+ *
+ * @param venueId - The venue ID
+ * @returns Fee configuration or null on error
+ */
+export declare function getVenueFees(venueId: string | number): Promise<{
+    serviceFeePercentage: number;
+    serviceFeeCents: number;
+    taxPercentage: number;
+} | null>;
+/**
+ * Get venue by slug
+ *
+ * Fetches venue using its URL-friendly slug.
+ *
+ * @param slug - The venue slug
+ * @returns Venue details or null on error
+ */
+export declare function getVenueBySlug(slug: string): Promise<Venue | null>;

package/dist/api/api/waitlist.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Waitlist API
+ *
+ * Endpoints for the sold-out-event waitlist flow.
+ */
+export interface JoinWaitlistResult {
+    success: boolean;
+    updated?: boolean;
+    error?: string;
+}
+/**
+ * Join the waitlist for a sold-out event.
+ */
+export declare function joinWaitlist(eventId: string | number, email: string, phone?: string | null, smsOptIn?: boolean): Promise<JoinWaitlistResult>;
+export interface ValidateWaitlistTokenResult {
+    valid: boolean;
+    eventId: number;
+    /**
+     * Present only when `valid` is false. One of the server's failure enums:
+     * invalid_token | token_expired | token_used | email_mismatch |
+     * inventory_exhausted. Callers map it to friendly copy.
+     */
+    errorCode?: string;
+}
+/**
+ * Validate a tokenized waitlist unlock link (decisions #3/#22/#36).
+ *
+ * A waitlister receives an email link carrying an opaque token bound to their
+ * email. Presenting a valid (token, email) pair unlocks the normal Buy Tickets
+ * flow on an otherwise-gated sold-out event, routing freed inventory to the
+ * notified buyer. Failures are surfaced (not thrown) so the page can show a
+ * non-blocking notice while keeping the event in its gated waitlist state.
+ */
+export declare function validateWaitlistToken(token: string, email: string): Promise<ValidateWaitlistTokenResult>;
+export interface WaitlistStatusResult {
+    waitlistEnabled: boolean;
+    soldOut: boolean;
+    /**
+     * When gated, the public event page should present "Sold Out — join the
+     * waitlist" to non-members even if tickets are technically available, and only
+     * a valid tokenized link unlocks checkout (reconciled decision #3).
+     */
+    gated: boolean;
+}
+/**
+ * Fetch an event's waitlist gating status. Returns a non-gated default if the
+ * request fails so the page degrades to normal behavior.
+ */
+export declare function getWaitlistStatus(eventId: string | number): Promise<WaitlistStatusResult>;