@getmicdrop/venue-calendar 4.3.1 → 4.3.2

package/dist/api/client.d.ts

@@ -0,0 +1,157 @@
+import { ApiConfig, ApiResponse } from './types.js';
+/**
+ * Per-request options. A superset of `RequestInit`: the two extra fields are
+ * consumed here and never reach `fetch`.
+ */
+export interface ApiRequestOptions extends RequestInit {
+    /**
+     * The widget key for THIS request, overriding the module-global one.
+     *
+     * The global (`config.js`'s `setWidgetKey`) is a single-instance
+     * convenience: two `<micdrop-calendar>` elements on one page with different
+     * keys both end up using whichever connected last, and the loser then 403s
+     * on every strict read and renders an empty calendar with no visible cause.
+     * `initVenueCalendar({ widgetKey })` threads the element's own key down to
+     * here so each instance authorizes with its own. The option name is FROZEN
+     * as `widgetKey` — VenueCalendar.js passes it under that name.
+     *
+     * TODO(seam: calendar-container-shell / embed-origin-config-surface): this is
+     * the transport half only. VenueCalendar.js hands the key to
+     * CalendarContainer as a prop; until the components that issue the reads pass
+     * it back down as `apiGet(url, { widgetKey })`, the module global is still
+     * what authorizes them and two differently-keyed embeds on one page still
+     * collapse into one key. The TODO in VenueCalendar.js that points HERE is
+     * discharged; the one pointing outward is not.
+     */
+    widgetKey?: string;
+    /**
+     * Skip the global `onError` handler for this call.
+     *
+     * For endpoints where a non-2xx is an EXPECTED, handled answer rather than a
+     * fault — /tax-preview's 422 "this venue has no tax address, show $0" is the
+     * live example. Without this the caller has to bypass the whole api-client
+     * with a raw `fetch` just to avoid emitting API-error noise on the happy
+     * path, which is how the hardcoded `https://get-micdrop.com` tax-preview URL
+     * in CartView survived (and broke every venue-hosted embed, which cannot
+     * reach a URL pinned to our own origin under its own CSP/consent rules).
+     */
+    suppressOnError?: boolean;
+}
+/**
+ * Observers of backend failure CODES, for cross-cutting state that no single
+ * caller owns.
+ *
+ * The concrete case is the buy path's `ORIGIN_NOT_REGISTERED` (embed audit
+ * 2026-08-22): every cart/promo/payment call can raise it, but the thing that
+ * has to react is the calendar shell, which makes none of those calls. Rather
+ * than thread the code back through six call sites, whoever cares subscribes
+ * here. Observers see EVERY failure code, so they must filter, and a throwing
+ * observer is contained — a broken subscriber must not turn a handled API
+ * error into an unhandled one.
+ */
+type ApiErrorCodeObserver = (_code: string) => void;
+/** Subscribe to backend failure codes. Returns an unsubscribe function. */
+export declare function onApiErrorCode(observer: ApiErrorCodeObserver): () => void;
+/**
+ * A response, plus the machine-readable failure code when there was one.
+ *
+ * Widens `ApiResponse` rather than replacing it, so every existing caller that
+ * annotates `ApiResponse<T>` keeps compiling.
+ */
+export interface ApiResult<T> extends ApiResponse<T> {
+    /**
+     * The backend's `code` for a failure — `WIDGET_KEY_INVALID`,
+     * `WIDGET_VENUE_MISMATCH`, `WIDGET_ORG_MISMATCH`, `NOT_FOUND`, … Before this
+     * existed the only thing that survived a failed request was a human-readable
+     * `error` string handed to `logger.error`, so a widget embedded on the wrong
+     * domain, a key scoped to another org, and a genuine outage were all the same
+     * "something went wrong" to the UI. The shell keys its message off this.
+     */
+    errorCode?: string;
+    /**
+     * The CALLER's AbortSignal fired — a superseded in-flight request, not a
+     * failure. Distinguished from a timeout (which also surfaces as an
+     * AbortError) because callers debouncing a request must leave their state
+     * untouched on an abort and reset it on a real failure.
+     */
+    aborted?: boolean;
+}
+/**
+ * The Error handed to the global `onError` handler, carrying the same code the
+ * returned `ApiResult` does. `onError` receives an `Error` by contract, so the
+ * code rides as a property rather than being flattened into the message.
+ */
+export declare class ApiRequestError extends Error {
+    readonly code?: string;
+    readonly statusCode?: number;
+    constructor(message: string, code?: string, statusCode?: number);
+}
+export declare function configureApi(config: Partial<ApiConfig>): void;
+export declare function getApiConfig(): Required<ApiConfig>;
+export declare function getPublicBaseUrl(): string;
+export declare function getLegacyPublicUrl(): string;
+export declare function getOrdersV2Url(): string;
+/** @deprecated IP is now resolved server-side via request headers. */
+export declare function getClientIP(): Promise<string>;
+export declare function apiGet<T>(endpoint: string, options?: ApiRequestOptions): Promise<ApiResult<T>>;
+export declare function apiPost<T>(endpoint: string, body?: unknown, options?: ApiRequestOptions): Promise<ApiResult<T>>;
+export declare function apiPut<T>(endpoint: string, body?: unknown, options?: ApiRequestOptions): Promise<ApiResult<T>>;
+export declare function apiDelete<T>(endpoint: string, options?: ApiRequestOptions): Promise<ApiResult<T>>;
+/** One priced line in a tax quote. `amountCents` is the LINE total, not unit. */
+export interface TaxPreviewLineItem {
+    amountCents: number;
+    reference: string;
+    quantity: number;
+}
+export interface TaxPreviewRequest {
+    venueId: number;
+    /** WHICH SHOW the quote is for — honours a per-event tax exemption (MIC-2606). */
+    eventId?: number;
+    lineItems: TaxPreviewLineItem[];
+    /** Order-level promo discount in integer cents (MIC-2567). */
+    discountCents?: number;
+    /** Ask the server for the authoritative service fee alongside the tax. */
+    computeServiceFee?: boolean;
+}
+/** Both fields are integer CENTS, and both are contract-optional. */
+export interface TaxPreviewResponse {
+    taxTotal?: number;
+    serviceFeeCents?: number;
+}
+/**
+ * Server-authoritative tax (and, optionally, service fee) quote.
+ *
+ * Exists so the cart summary does not have to bypass this client to get one.
+ * The raw `fetch` it replaces hardcoded `https://get-micdrop.com/...`, which is
+ * the whole third-party-domain bug in one line: an embed on a venue's own
+ * domain could not retarget it at all, so a self-hosted or proxied deployment
+ * quoted tax from the wrong origin (or, under a strict CSP, not at all).
+ *
+ * `suppressOnError` defaults TRUE because a 422 here is a documented, handled
+ * answer — "this venue has no address configured for Stripe Tax, show $0" — and
+ * routing it through the global onError handler is what made the raw fetch look
+ * necessary. Callers still see the 422 in `statusCode` and must apply their own
+ * fallback; genuine 5xx/network failures are theirs to log.
+ *
+ * @param req - the quote request; `lineItems` may be empty, but prefer not
+ *   calling at all in that case (the server has nothing to price).
+ * @param options.signal - abort a superseded quote. An abort comes back as
+ *   `{ aborted: true }`, NOT as a failure, so a debouncing caller can return
+ *   early without clobbering the numbers it is still showing.
+ */
+export declare function taxPreview(req: TaxPreviewRequest, options?: {
+    signal?: AbortSignal;
+    suppressOnError?: boolean;
+}): Promise<ApiResult<TaxPreviewResponse>>;
+/**
+ * Simple fetch wrapper that returns parsed JSON or null on error.
+ * Inherits the global timeout + retry policy for GETs.
+ *
+ * NOTE: this was slated for deletion on the premise that it had no production
+ * callers. It has seven — events.ts (loadResult, resolvePublicEntity, the
+ * collection loader and both password checks), orders.ts's getOrder, and
+ * view-tickets/defaults.ts — so it stays. What it does NOT do any more is send
+ * credentials; see the apiRequest comment for why that is the point.
+ */
+export declare function simpleFetch<T>(url: string, options?: RequestInit & Pick<ApiRequestOptions, 'widgetKey'>): Promise<T | null>;
+export {};

package/dist/api/cta.d.ts

@@ -0,0 +1,50 @@
+import { isHiddenTicketPurchasable } from '@getmicdrop/svelte-components/transforms';
+export interface CtaStateOptions {
+    cancelled?: boolean;
+    isRegistration?: boolean;
+    waitlistEnabled?: boolean;
+}
+export interface CtaState {
+    text: string;
+    disabled: boolean;
+    reason: 'cancelled' | 'event_past' | 'no_tickets' | 'available' | 'coming_soon' | 'sold_out_waitlist' | 'sold_out' | 'sales_ended' | 'sales_paused' | 'postponed' | 'hidden_only';
+}
+interface CtaEvent {
+    startDateTime?: string | null;
+    endDateTime?: string | null;
+    hasPurchasableHiddenTickets?: boolean;
+    /**
+     * The event's own LIFECYCLE (MIC-2531) — draft | live | started | ended |
+     * canceled | postponed. Distinct from {@link CtaEvent.salesStatus}, which is
+     * the operator's sales dial: a show can be live with sales paused, and a
+     * postponed show is not the same thing as a paused one however alike the two
+     * look from the till.
+     */
+    status?: string | null;
+    /**
+     * The operator's sales dial (MIC-2455). On the PUBLIC payload this is already
+     * the effective value — the backend merges any manual override into it. The
+     * ADMIN payload does NOT merge: there `salesStatus` is the computed value and
+     * `salesStatusOverride` is what the operator forced, so an admin-shaped event
+     * read through here would answer with the wrong dial.
+     */
+    salesStatus?: string | null;
+}
+interface CtaTicket {
+    salesChannel?: number;
+    salesBegin?: string | null;
+    salesStart?: string | null;
+    saleBegin?: string | null;
+    onSaleStart?: string | null;
+    salesEnd?: string | null;
+    saleEnd?: string | null;
+    onSaleEnd?: string | null;
+    remainingCapacity?: number | null;
+    quantityRemaining?: number | null;
+    quantity?: number | null;
+    soldOut?: boolean;
+    isHidden?: boolean;
+    visibility?: number;
+}
+export { isHiddenTicketPurchasable };
+export declare function computeCtaState(event: CtaEvent, tickets: CtaTicket[] | undefined, options?: CtaStateOptions): CtaState;

package/dist/api/events.d.ts

@@ -0,0 +1,202 @@
+import { Result } from './result.js';
+import { Event, AvailableTicket, EventPerformersResponse, SeriesOccurrencesResponse, PublicCollectionData, ResolvedEntity } from './types.js';
+/**
+ * Fetch event details, discriminating a real 404 from a transient failure.
+ *
+ * The SSR loader (`[id]/[slug]/+page.js`) gates its HTTP status on this: only an
+ * upstream 404 (`errNotFound`) becomes a page 404. A 5xx, a network error, or a
+ * timeout is `err(...)` (transient) so the loader can answer 503/retry instead
+ * of rendering a permanent-looking 404 to a buyer or crawler on a backend blip.
+ *
+ * @param eventId - The event ID
+ * @param customFetch - Optional custom fetch function (for SSR)
+ * @param password - Optional password for gated events
+ * @returns `ok(event)`, `errNotFound(...)` for a real 404, or `err(...)` transient
+ */
+export declare function fetchEventDetailsResult(eventId: string | number, customFetch?: typeof fetch, password?: string): Promise<Result<Event>>;
+/**
+ * Fetch event details
+ *
+ * Gets full event information including venue and ticket data.
+ *
+ * Fail-open adapter over {@link fetchEventDetailsResult}: existing in-widget
+ * callers (Checkout, CartView, EventPage) keep degrading to `null` on any
+ * failure. SSR loaders that need to answer 404-vs-503 use the Result variant.
+ *
+ * @param eventId - The event ID
+ * @param customFetch - Optional custom fetch function (for SSR)
+ * @returns Event details or null on error
+ */
+export declare function fetchEventDetails(eventId: string | number, customFetch?: typeof fetch, password?: string): Promise<Event | null>;
+/**
+ * Fetch available tickets for an event
+ *
+ * Returns all ticket types that are currently available for sale.
+ *
+ * @param eventId - The event ID
+ * @returns Array of available tickets
+ */
+export declare function fetchEventTicketsResult(eventId: string | number, promoCode?: string): Promise<Result<AvailableTicket[]>>;
+export declare function fetchEventTickets(eventId: string | number, promoCode?: string): Promise<AvailableTicket[]>;
+/**
+ * Fetch performers for an event
+ *
+ * Returns the lineup with pre-resolved avatar URLs.
+ *
+ * @param eventId - The event ID
+ * @returns Performers list and visibility flag
+ */
+export declare function fetchEventPerformersResult(eventId: string | number): Promise<Result<EventPerformersResponse>>;
+export declare function fetchEventPerformers(eventId: string | number): Promise<EventPerformersResponse>;
+/**
+ * Fetch all venues for an organization
+ *
+ * @param orgId - The organization ID
+ * @returns Array of venues
+ */
+export declare function fetchAllVenuesResult(orgId: string | number): Promise<Result<any[]>>;
+export declare function fetchAllVenues(orgId: string | number): Promise<any[]>;
+/**
+ * Fetch events for a venue
+ *
+ * @param venueId - The venue ID
+ * @returns Array of events
+ */
+export declare function fetchVenueEventsResult(venueId: string | number): Promise<Result<Event[]>>;
+export declare function fetchVenueEvents(venueId: string | number): Promise<Event[]>;
+/**
+ * Options for a month read.
+ *
+ * `fresh` means "this caller must not be handed an answer that was already on
+ * the wire". It exists for the live status stream: when the backend says a show
+ * was canceled or postponed, CalendarContainer force-refreshes that month, and
+ * an in-flight response may have been snapshotted by the server BEFORE the
+ * change that triggered the refresh. Joining it would leave a canceled show
+ * drawn as on-sale until the next envelope — the exact staleness
+ * CalendarContainer's own force path exists to prevent.
+ *
+ * A fresh read also REPLACES the shared entry, so anyone joining afterwards
+ * waits on the post-change request rather than the one it superseded. Two
+ * instances that both force on the same envelope still share, because both of
+ * their requests are post-change.
+ */
+export interface MonthReadOptions {
+    fresh?: boolean;
+}
+export declare function getMonthEventsResult(venueId: string | number, year: number, month: number, options?: MonthReadOptions): Promise<Result<Event[]>>;
+export declare function getMonthEvents(venueId: string | number, year: number, month: number): Promise<Event[]>;
+/**
+ * Get events for an organization for a specific month
+ *
+ * @param orgId - The organization ID
+ * @param year - The year (e.g., 2024)
+ * @param month - The month (1-12)
+ * @returns Array of events for the month
+ */
+export declare function getOrgMonthEventsResult(orgId: string | number, year: number, month: number, options?: MonthReadOptions): Promise<Result<Event[]>>;
+export declare function getOrgMonthEvents(orgId: string | number, year: number, month: number): Promise<Event[]>;
+/**
+ * Get series occurrences for date selector
+ *
+ * Returns all instances of a recurring event series.
+ *
+ * @param eventSeriesId - The series ID
+ * @returns Series occurrences
+ */
+export declare function getSeriesOccurrencesResult(eventSeriesId: number): Promise<Result<SeriesOccurrencesResponse>>;
+export declare function getSeriesOccurrences(eventSeriesId: number): Promise<SeriesOccurrencesResponse | null>;
+/**
+ * Fetch series occurrences with CTA state
+ *
+ * Returns full series data including availability status.
+ *
+ * @param eventSeriesId - The series ID
+ * @param venueId - The venue ID
+ * @returns Series occurrences with CTA state
+ */
+export declare function fetchSeriesOccurrencesResult(eventSeriesId: number, venueId: string | number): Promise<Result<SeriesOccurrencesResponse>>;
+export declare function fetchSeriesOccurrences(eventSeriesId: number, venueId: string | number): Promise<SeriesOccurrencesResponse | null>;
+/**
+ * Resolve an entity-agnostic public id to its concrete type + data.
+ *
+ * The embed deep-link (`#{id}-{slug}`) carries no type prefix, so a cold
+ * deep link (the show isn't in the loaded calendar month) needs the backend
+ * to say whether the id is an event, series, or collection before the widget
+ * can render the right view. This is the same `/api/v2/public/resolve/{id}`
+ * endpoint get-micdrop.com's `/e/{slugId}` page resolves server-side; here we
+ * call it cross-origin from the venue's page (the public API already serves
+ * the calendar cross-origin, so CORS is in place).
+ *
+ * @param id - The entity id (numeric, type-agnostic)
+ * @param slug - Optional slug hint (lets the backend canonicalize)
+ * @returns `{ type, id, title, data }` or null on failure
+ */
+export declare function resolvePublicEntity(id: string | number, slug?: string): Promise<ResolvedEntity | null>;
+/**
+ * Fetch public collection data
+ *
+ * Returns collection info including events list.
+ * For password-protected collections, pass the password to authenticate.
+ *
+ * @param collectionId - The collection ID
+ * @param password - Optional password for protected collections
+ * @returns Collection data or null on error
+ */
+export declare function fetchPublicCollection(collectionId: string | number, password?: string): Promise<PublicCollectionData | null>;
+/**
+ * Check collection password
+ *
+ * Validates password for password-protected collections.
+ *
+ * @param collectionId - The collection ID
+ * @param password - The password to check
+ * @returns Whether the password is valid
+ */
+export declare function checkCollectionPassword(collectionId: string | number, password: string): Promise<boolean>;
+/**
+ * Check event password
+ *
+ * Validates password for password-protected events.
+ *
+ * @param eventId - The event ID
+ * @param password - The password to check
+ * @returns Whether the password is valid
+ */
+export declare function checkEventPassword(eventId: string | number, password: string): Promise<{
+    valid: boolean;
+}>;
+/**
+ * Test network connection
+ *
+ * Asks whether the public API is reachable.
+ *
+ * THE QUESTION IS "DID THE ROUTER ANSWER", NOT "DID THE RESOURCE EXIST" — the
+ * same distinction route-manifest.ts is built on. Under the old `response.ok`
+ * rule this probe reported the API DOWN on a healthy backend on EVERY branch,
+ * for EVERY input, always. Measured against production: HEAD answers 405 on
+ * every route the backend serves — including `HEAD /events/venue/42` for a venue
+ * that EXISTS — and the old `HEAD /health` branch answered 404, because the
+ * router does not serve /health at all. None of those are `ok`. A liveness check
+ * that always fails is worse than none.
+ *
+ * Two changes fix two different things, and they are separable:
+ *
+ *   1. THE STATUS RULE is what fixes liveness. Reachable means ANSWERED, not
+ *      `response.ok`. A 400, a 404 or a 405 is the backend talking: it is up.
+ *      Only a transport failure (DNS, TLS, CORS, offline) or a 5xx means it is
+ *      not serving. This rule alone would have made liveness report up, even on
+ *      the old /health probe (404 < 500).
+ *   2. THE REPOINT is what stops this naming a route the router does not serve —
+ *      the name-resolution gate, and #444. Every branch now names a route the
+ *      backend actually SERVES. There is no id-free public route, so the no-ids
+ *      branch asks a served route about an id that cannot exist: we do not care
+ *      what it says about the venue, only that it said anything at all. This is
+ *      not what fixes liveness.
+ *
+ * Do not "simplify" `status < 500` back to `response.ok`. That is the bug.
+ *
+ * @param orgId - Optional org ID
+ * @param venueId - Optional venue ID
+ * @returns Whether the API answered
+ */
+export declare function testNetworkConnection(orgId?: string | number, venueId?: string | number): Promise<boolean>;

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

@@ -0,0 +1,119 @@
+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;
+    /**
+     * Amount still owed after the removal, in DOLLARS, as the server computed it.
+     * `undefined` when the cart is not yet priced (the server sends null) — the
+     * caller must then leave its own total alone rather than infer a zero.
+     */
+    remainingTotal?: number;
+}
+/**
+ * Remove a gift card from a cart. Identify a single stacked card by `giftCardId`
+ * (what the cart response gives — codes come back masked) or by `code` for one
+ * applied in this same session. Pass neither to remove ALL applied cards.
+ */
+export declare function removeGiftCard(cartId: string, target?: {
+    giftCardId?: number;
+    code?: string;
+}): Promise<RemoveGiftCardResult>;
+export interface CompleteGiftCardPaymentInput {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phoneNumber?: string | null;
+    questionAnswer?: string;
+    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, uiLocale?: string): 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/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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, requeueWaitlistToFront, } from './waitlist.js';
+export type { JoinWaitlistResult, WaitlistStatusResult, ValidateWaitlistTokenResult, RequeueWaitlistResult, } 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';