@theatrical/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2080 @@
+// src/utils/validate-config.ts
+import { ZodError } from "zod";
+
+// src/types/config.ts
+import { z } from "zod";
+var theatricalConfigSchema = z.object({
+  apiKey: z.string().min(1, "apiKey must not be empty").regex(/^[A-Za-z0-9_-]+$/, "apiKey must contain only alphanumeric characters, hyphens, and underscores"),
+  environment: z.enum(["sandbox", "staging", "production"]).optional().default("sandbox"),
+  baseUrl: z.string().url("baseUrl must be a valid URL").optional(),
+  timeout: z.number().int("timeout must be an integer").positive("timeout must be a positive number").max(12e4, "timeout must not exceed 120000ms").optional().default(3e4),
+  maxRetries: z.number().int("maxRetries must be an integer").min(0, "maxRetries must be 0 or greater").max(10, "maxRetries must not exceed 10").optional().default(3),
+  debug: z.boolean().optional().default(false)
+});
+
+// src/errors/codes.ts
+var VISTA_ERROR_CODES = {
+  // Auth
+  AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED",
+  AUTH_TOKEN_INVALID: "AUTH_TOKEN_INVALID",
+  AUTH_TOKEN_MISSING: "AUTH_TOKEN_MISSING",
+  AUTH_INSUFFICIENT_SCOPE: "AUTH_INSUFFICIENT_SCOPE",
+  AUTH_API_KEY_INVALID: "AUTH_API_KEY_INVALID",
+  // Rate limiting
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+  // Validation
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  INVALID_PARAMETER: "INVALID_PARAMETER",
+  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
+  INVALID_DATE_FORMAT: "INVALID_DATE_FORMAT",
+  INVALID_CURRENCY: "INVALID_CURRENCY",
+  // Resources
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  SESSION_EXPIRED: "SESSION_EXPIRED",
+  SESSION_SOLD_OUT: "SESSION_SOLD_OUT",
+  SEAT_UNAVAILABLE: "SEAT_UNAVAILABLE",
+  FILM_NOT_FOUND: "FILM_NOT_FOUND",
+  SITE_NOT_FOUND: "SITE_NOT_FOUND",
+  ORDER_NOT_FOUND: "ORDER_NOT_FOUND",
+  ORDER_ALREADY_CONFIRMED: "ORDER_ALREADY_CONFIRMED",
+  ORDER_CANCELLATION_WINDOW_EXPIRED: "ORDER_CANCELLATION_WINDOW_EXPIRED",
+  MEMBER_NOT_FOUND: "MEMBER_NOT_FOUND",
+  // Server
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  UPSTREAM_TIMEOUT: "UPSTREAM_TIMEOUT"
+};
+var VISTA_ERROR_MESSAGES = {
+  [VISTA_ERROR_CODES.AUTH_TOKEN_EXPIRED]: "Your access token has expired. Re-authenticate and retry.",
+  [VISTA_ERROR_CODES.AUTH_TOKEN_INVALID]: "The provided access token is invalid.",
+  [VISTA_ERROR_CODES.AUTH_TOKEN_MISSING]: "No access token was provided.",
+  [VISTA_ERROR_CODES.AUTH_INSUFFICIENT_SCOPE]: "The access token does not have the required permissions.",
+  [VISTA_ERROR_CODES.AUTH_API_KEY_INVALID]: "The API key is invalid or has been revoked.",
+  [VISTA_ERROR_CODES.RATE_LIMIT_EXCEEDED]: "Too many requests. Please slow down.",
+  [VISTA_ERROR_CODES.QUOTA_EXCEEDED]: "API quota exceeded for this billing period.",
+  [VISTA_ERROR_CODES.VALIDATION_FAILED]: "One or more fields failed validation.",
+  [VISTA_ERROR_CODES.INVALID_PARAMETER]: "A request parameter contains an invalid value.",
+  [VISTA_ERROR_CODES.MISSING_REQUIRED_FIELD]: "A required field is missing from the request.",
+  [VISTA_ERROR_CODES.INVALID_DATE_FORMAT]: "Date must be in ISO 8601 format (YYYY-MM-DD).",
+  [VISTA_ERROR_CODES.INVALID_CURRENCY]: "Currency code must be a valid ISO 4217 code (e.g. NZD, AUD).",
+  [VISTA_ERROR_CODES.SESSION_NOT_FOUND]: "The requested session does not exist.",
+  [VISTA_ERROR_CODES.SESSION_EXPIRED]: "This session has already passed.",
+  [VISTA_ERROR_CODES.SESSION_SOLD_OUT]: "This session is sold out.",
+  [VISTA_ERROR_CODES.SEAT_UNAVAILABLE]: "One or more selected seats are no longer available.",
+  [VISTA_ERROR_CODES.FILM_NOT_FOUND]: "The requested film does not exist.",
+  [VISTA_ERROR_CODES.SITE_NOT_FOUND]: "The requested cinema site does not exist.",
+  [VISTA_ERROR_CODES.ORDER_NOT_FOUND]: "The requested order does not exist.",
+  [VISTA_ERROR_CODES.ORDER_ALREADY_CONFIRMED]: "This order has already been confirmed.",
+  [VISTA_ERROR_CODES.ORDER_CANCELLATION_WINDOW_EXPIRED]: "The cancellation window for this order has passed.",
+  [VISTA_ERROR_CODES.MEMBER_NOT_FOUND]: "The requested member does not exist.",
+  [VISTA_ERROR_CODES.INTERNAL_ERROR]: "An internal server error occurred. Please try again.",
+  [VISTA_ERROR_CODES.SERVICE_UNAVAILABLE]: "The service is temporarily unavailable.",
+  [VISTA_ERROR_CODES.UPSTREAM_TIMEOUT]: "The upstream service timed out."
+};
+function resolveVistaMessage(code, fallback) {
+  if (!code) return fallback;
+  return VISTA_ERROR_MESSAGES[code] ?? fallback;
+}
+
+// src/errors/parser.ts
+async function tryParseBody(response) {
+  try {
+    const text = await response.text();
+    if (!text) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function isVistaEnvelope(body) {
+  return typeof body === "object" && body !== null && ("code" in body || "message" in body || "errors" in body);
+}
+function isOcapiEnvelope(body) {
+  return typeof body === "object" && body !== null && "fault" in body;
+}
+function extractFieldErrors(errors) {
+  if (!errors || errors.length === 0) return {};
+  return Object.fromEntries(errors.map((e) => [e.field, e.message]));
+}
+function parseRetryAfter(response) {
+  const raw = response.headers.get("Retry-After");
+  if (!raw) return 60;
+  const seconds = parseInt(raw, 10);
+  if (!isNaN(seconds) && seconds >= 0) return seconds;
+  const date = new Date(raw);
+  if (!isNaN(date.getTime())) {
+    const delta = Math.ceil((date.getTime() - Date.now()) / 1e3);
+    return Math.max(0, delta);
+  }
+  return 60;
+}
+function extractResource(vistaCode, requestUrl) {
+  const CODE_TO_RESOURCE = {
+    SESSION_NOT_FOUND: "Session",
+    FILM_NOT_FOUND: "Film",
+    SITE_NOT_FOUND: "Site",
+    ORDER_NOT_FOUND: "Order",
+    MEMBER_NOT_FOUND: "Member"
+  };
+  const resource = (vistaCode && CODE_TO_RESOURCE[vistaCode]) ?? inferResourceFromUrl(requestUrl);
+  const id = requestUrl ? new URL(requestUrl, "https://api.vista.co").pathname.split("/").filter(Boolean).pop() ?? "unknown" : "unknown";
+  return { resource, resourceId: id };
+}
+function inferResourceFromUrl(url) {
+  if (!url) return "Resource";
+  const segments = url.split("/").filter(Boolean);
+  if (segments.length >= 2) {
+    const noun = segments[segments.length - 2];
+    return noun.charAt(0).toUpperCase() + noun.slice(1, -1);
+  }
+  return "Resource";
+}
+async function parseErrorResponse(response, requestUrl) {
+  const body = await tryParseBody(response);
+  const status = response.status;
+  let vistaCode;
+  let message;
+  let requestId;
+  let fieldErrors = {};
+  if (body && isVistaEnvelope(body)) {
+    vistaCode = body.code;
+    message = body.message;
+    requestId = body.requestId;
+    fieldErrors = extractFieldErrors(body.errors);
+  } else if (body && isOcapiEnvelope(body)) {
+    message = body.fault?.message;
+    vistaCode = body.fault?.type;
+  }
+  const resolvedMessage = resolveVistaMessage(vistaCode, message ?? `Request failed with status ${status}`);
+  if (status === 401 || status === 403) {
+    return new AuthenticationError(resolvedMessage, vistaCode, requestId);
+  }
+  if (status === 429) {
+    const retryAfter = parseRetryAfter(response);
+    return new RateLimitError(retryAfter, requestId);
+  }
+  if (status === 400 || status === 422) {
+    return new ValidationError(resolvedMessage, fieldErrors, requestId);
+  }
+  if (status === 404) {
+    const { resource, resourceId } = extractResource(vistaCode, requestUrl);
+    return new NotFoundError(resource, resourceId, requestId);
+  }
+  if (status >= 500) {
+    return new ServerError(resolvedMessage, requestId);
+  }
+  return new TheatricalError(resolvedMessage, status, vistaCode, requestId);
+}
+
+// src/errors/index.ts
+var TheatricalError = class extends Error {
+  statusCode;
+  vistaErrorCode;
+  requestId;
+  constructor(message, statusCode, vistaErrorCode, requestId) {
+    super(message);
+    this.name = "TheatricalError";
+    this.statusCode = statusCode;
+    this.vistaErrorCode = vistaErrorCode;
+    this.requestId = requestId;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      vistaErrorCode: this.vistaErrorCode,
+      requestId: this.requestId
+    };
+  }
+};
+var AuthenticationError = class extends TheatricalError {
+  constructor(message = "Authentication failed", vistaErrorCode, requestId) {
+    super(message, 401, vistaErrorCode, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends TheatricalError {
+  retryAfter;
+  constructor(retryAfter, requestId) {
+    super(`Rate limit exceeded. Retry after ${retryAfter}s`, 429, void 0, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValidationError = class extends TheatricalError {
+  fields;
+  constructor(message, fields = {}, requestId) {
+    super(message, 400, void 0, requestId);
+    this.name = "ValidationError";
+    this.fields = fields;
+  }
+};
+var NotFoundError = class extends TheatricalError {
+  resource;
+  resourceId;
+  constructor(resource, resourceId, requestId) {
+    super(`${resource} '${resourceId}' not found`, 404, void 0, requestId);
+    this.name = "NotFoundError";
+    this.resource = resource;
+    this.resourceId = resourceId;
+  }
+};
+var ServerError = class extends TheatricalError {
+  constructor(message = "Internal server error", requestId) {
+    super(message, 500, void 0, requestId);
+    this.name = "ServerError";
+  }
+};
+
+// src/utils/validate-config.ts
+function validateConfig(config) {
+  try {
+    return theatricalConfigSchema.parse(config);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const fields = {};
+      for (const issue of err.issues) {
+        const path = issue.path.join(".");
+        fields[path || "unknown"] = issue.message;
+      }
+      const firstField = Object.keys(fields)[0] ?? "config";
+      const firstMessage = fields[firstField] ?? "Invalid configuration";
+      throw new ValidationError(
+        `Invalid TheatricalConfig: ${firstField} \u2014 ${firstMessage}`,
+        fields
+      );
+    }
+    throw err;
+  }
+}
+
+// src/types/session.ts
+import { z as z2 } from "zod";
+var sessionFormatSchema = z2.enum([
+  "2D",
+  "3D",
+  "IMAX",
+  "IMAX3D",
+  "4DX",
+  "DOLBY_CINEMA",
+  "SCREENX",
+  "STANDARD"
+]);
+var seatStatusSchema = z2.enum([
+  "available",
+  "taken",
+  "reserved",
+  "wheelchair",
+  "companion",
+  "blocked"
+]);
+var sessionSchema = z2.object({
+  id: z2.string(),
+  filmId: z2.string(),
+  filmTitle: z2.string(),
+  siteId: z2.string(),
+  screenId: z2.string(),
+  screenName: z2.string(),
+  startTime: z2.string(),
+  endTime: z2.string(),
+  format: sessionFormatSchema,
+  isBookable: z2.boolean(),
+  isSoldOut: z2.boolean(),
+  seatsAvailable: z2.number().int().nonnegative(),
+  seatsTotal: z2.number().int().positive(),
+  priceFrom: z2.number().nonnegative().optional(),
+  currency: z2.string().length(3).optional(),
+  attributes: z2.record(z2.string(), z2.string())
+});
+var sessionFilterSchema = z2.object({
+  siteId: z2.string().optional(),
+  filmId: z2.string().optional(),
+  date: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  dateFrom: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  dateTo: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  format: sessionFormatSchema.optional(),
+  bookableOnly: z2.boolean().optional(),
+  limit: z2.number().int().positive().max(500).optional(),
+  offset: z2.number().int().nonnegative().optional(),
+  cursor: z2.string().optional()
+});
+var sessionListResponseSchema = z2.object({
+  sessions: z2.array(sessionSchema),
+  total: z2.number().int().nonnegative(),
+  hasMore: z2.boolean(),
+  nextOffset: z2.number().int().nonnegative().optional(),
+  nextCursor: z2.string().optional()
+});
+var seatSchema = z2.object({
+  id: z2.string(),
+  row: z2.string(),
+  number: z2.number().int().positive(),
+  status: seatStatusSchema,
+  x: z2.number(),
+  y: z2.number(),
+  type: z2.string().optional(),
+  isAccessible: z2.boolean()
+});
+var seatAvailabilitySchema = z2.object({
+  sessionId: z2.string(),
+  screenName: z2.string(),
+  seats: z2.array(seatSchema),
+  rowCount: z2.number().int().positive(),
+  screenPosition: z2.enum(["top", "bottom"]),
+  availableCount: z2.number().int().nonnegative(),
+  totalCount: z2.number().int().positive()
+});
+
+// src/resources/sessions.ts
+var DEFAULT_PAGE_SIZE = 50;
+var SessionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List sessions (showtimes) with optional filters.
+   * Response is validated at runtime using Zod — malformed API responses throw a parse error.
+   * @throws {TheatricalError} When the API returns an error response
+   * @throws {z.ZodError} When the response fails schema validation
+   * @see https://developer.vista.co/digital-platform/sessions/
+   */
+  async list(filters) {
+    const raw = await this.http.get("/ocapi/v1/sessions", {
+      params: filters
+    });
+    return sessionListResponseSchema.parse(raw);
+  }
+  /**
+   * List sessions with explicit pagination control.
+   *
+   * Returns a normalised `PaginatedResponse<Session>` envelope that includes
+   * the pagination strategy and cursor/offset for the next page.
+   *
+   * @param filters - Session filters (site, film, date range, etc.)
+   * @param pagination - Page size and cursor/offset position
+   * @returns A single page of sessions with pagination metadata
+   *
+   * @example
+   * ```typescript
+   * const page = await client.sessions.listPaginated(
+   *   { siteId: 'roxy-wellington' },
+   *   { limit: 25 },
+   * );
+   * console.log(page.data.length, page.hasMore);
+   * ```
+   */
+  async listPaginated(filters, pagination) {
+    const limit = pagination?.limit ?? DEFAULT_PAGE_SIZE;
+    const useCursor = pagination?.cursor !== void 0;
+    const response = await this.list({
+      ...filters,
+      limit,
+      ...useCursor ? { cursor: pagination.cursor } : { offset: pagination?.offset ?? 0 }
+    });
+    return {
+      data: response.sessions,
+      total: response.total,
+      hasMore: response.hasMore,
+      nextCursor: response.nextCursor,
+      nextOffset: response.nextOffset,
+      strategy: useCursor ? "cursor" : "offset"
+    };
+  }
+  /**
+   * Async generator that automatically paginates through all matching sessions.
+   *
+   * Yields individual `Session` objects, fetching the next page transparently
+   * when the current page is exhausted. Uses offset-based pagination internally
+   * since Vista's session endpoints support numeric offsets.
+   *
+   * @param filters - Session filters (site, film, date range, etc.)
+   * @param pageSize - Number of sessions to fetch per page (default: 50, max: 500)
+   *
+   * @example
+   * ```typescript
+   * const allSessions: Session[] = [];
+   * for await (const session of client.sessions.listAll({ siteId: 'roxy-wellington' })) {
+   *   allSessions.push(session);
+   * }
+   * ```
+   *
+   * @example Collect with early termination
+   * ```typescript
+   * for await (const session of client.sessions.listAll({ date: '2026-04-10' })) {
+   *   if (session.isSoldOut) continue;
+   *   console.log(`${session.filmTitle} — ${session.screenName} @ ${session.startTime}`);
+   *   if (!session.isBookable) break; // stop on first unbookable
+   * }
+   * ```
+   */
+  async *listAll(filters, pageSize = DEFAULT_PAGE_SIZE) {
+    let offset = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const response = await this.list({
+        ...filters,
+        limit: pageSize,
+        offset
+      });
+      for (const session of response.sessions) {
+        yield session;
+      }
+      hasMore = response.hasMore;
+      offset = response.nextOffset ?? offset + response.sessions.length;
+    }
+  }
+  /**
+   * Get a single session by ID.
+   * Response is validated at runtime using Zod.
+   */
+  async get(sessionId) {
+    const raw = await this.http.get(`/ocapi/v1/sessions/${sessionId}`);
+    return sessionSchema.parse(raw);
+  }
+  /**
+   * Get seat availability for a session.
+   * Returns the complete auditorium seat map with status for each seat.
+   * Response is validated at runtime using Zod.
+   */
+  async availability(sessionId) {
+    const raw = await this.http.get(`/ocapi/v1/sessions/${sessionId}/seat-plan`);
+    return seatAvailabilitySchema.parse(raw);
+  }
+};
+
+// src/types/site.ts
+import { z as z3 } from "zod";
+var geoLocationSchema = z3.object({
+  latitude: z3.number().min(-90).max(90),
+  longitude: z3.number().min(-180).max(180)
+});
+var addressSchema = z3.object({
+  line1: z3.string(),
+  line2: z3.string().optional(),
+  city: z3.string(),
+  state: z3.string().optional(),
+  postalCode: z3.string(),
+  country: z3.string().length(2)
+});
+var screenSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  seatCount: z3.number().int().positive(),
+  formats: z3.array(z3.string()).min(1),
+  isAccessible: z3.boolean()
+});
+var amenitySchema = z3.object({
+  /** Amenity identifier (e.g. 'parking', 'bar', 'vip_lounge', 'imax') */
+  id: z3.string(),
+  /** Human-readable label */
+  label: z3.string(),
+  /** Optional icon key for rendering */
+  icon: z3.string().optional()
+});
+var siteConfigSchema = z3.object({
+  bookingLeadTime: z3.number().int().nonnegative(),
+  maxTicketsPerOrder: z3.number().int().positive(),
+  loyaltyEnabled: z3.boolean(),
+  fnbEnabled: z3.boolean()
+});
+var siteSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  address: addressSchema,
+  location: geoLocationSchema,
+  screens: z3.array(screenSchema),
+  config: siteConfigSchema,
+  timezone: z3.string(),
+  currency: z3.string().length(3),
+  isActive: z3.boolean(),
+  amenities: z3.array(amenitySchema).optional()
+});
+var siteListResponseSchema = z3.array(siteSchema);
+
+// src/resources/sites.ts
+var SitesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all cinema sites, with optional search query or geographic filter.
+   * Response is validated at runtime using Zod.
+   *
+   * @param filters - Optional filters: `query` (text search), `latitude`/`longitude`/`radius`
+   * @returns Array of cinema sites
+   * @throws {TheatricalError} When the API returns an error response
+   * @throws {z.ZodError} When the response fails schema validation
+   *
+   * @example
+   * ```typescript
+   * const sites = await client.sites.list({ query: 'Embassy' });
+   * ```
+   */
+  async list(filters) {
+    const params = {};
+    if (filters?.query) params.query = filters.query;
+    if (filters?.latitude !== void 0) params.latitude = filters.latitude;
+    if (filters?.longitude !== void 0) params.longitude = filters.longitude;
+    if (filters?.radius !== void 0) params.radius = filters.radius;
+    const raw = await this.http.get("/ocapi/v1/sites", { params });
+    return siteListResponseSchema.parse(raw);
+  }
+  /**
+   * Get a single cinema site by ID.
+   * Response is validated at runtime using Zod.
+   *
+   * @param siteId - Vista site identifier
+   * @returns The site record
+   *
+   * @example
+   * ```typescript
+   * const roxy = await client.sites.get('site_roxy_wellington');
+   * console.log(roxy.screens.length); // number of auditoriums
+   * ```
+   */
+  async get(siteId) {
+    const raw = await this.http.get(`/ocapi/v1/sites/${siteId}`);
+    return siteSchema.parse(raw);
+  }
+  /**
+   * Get the screen (auditorium) configurations for a site.
+   * Returns each screen's capacity, supported formats, and accessibility status.
+   * Response is validated at runtime using Zod.
+   *
+   * @param siteId - Vista site identifier
+   * @returns Array of screen configurations
+   *
+   * @example
+   * ```typescript
+   * const screens = await client.sites.screens('site_embassy_wellington');
+   * const imax = screens.find(s => s.formats.includes('IMAX'));
+   * ```
+   */
+  async screens(siteId) {
+    const raw = await this.http.get(`/ocapi/v1/sites/${siteId}/screens`);
+    return screenSchema.array().parse(raw);
+  }
+  /**
+   * Find cinema sites within a geographic radius.
+   *
+   * Returns sites sorted by distance from the given coordinates.
+   * Uses Vista's OCAPI geographic search which accepts decimal lat/lng
+   * and a radius in kilometres.
+   *
+   * @param latitude - Decimal latitude of the search centre (−90 to 90)
+   * @param longitude - Decimal longitude of the search centre (−180 to 180)
+   * @param radiusKm - Search radius in kilometres
+   * @returns Sites within the radius, sorted nearest-first
+   *
+   * @example
+   * ```typescript
+   * // Find cinemas within 5 km of Roxy Cinema Wellington
+   * const nearby = await client.sites.nearby(-41.3007, 174.7766, 5);
+   * console.log(nearby.map(s => s.name));
+   * ```
+   *
+   * @example Discover cinemas near central Auckland
+   * ```typescript
+   * const auckland = await client.sites.nearby(-36.8509, 174.7645, 10);
+   * ```
+   */
+  async nearby(latitude, longitude, radiusKm) {
+    const raw = await this.http.get("/ocapi/v1/sites", {
+      params: { latitude, longitude, radius: radiusKm }
+    });
+    return siteListResponseSchema.parse(raw);
+  }
+};
+
+// src/types/film.ts
+import { z as z4 } from "zod";
+var GENRES = [
+  "action",
+  "adventure",
+  "animation",
+  "comedy",
+  "crime",
+  "documentary",
+  "drama",
+  "family",
+  "fantasy",
+  "horror",
+  "musical",
+  "mystery",
+  "romance",
+  "sci-fi",
+  "thriller",
+  "war",
+  "western"
+];
+var FILM_FORMATS = ["2D", "3D", "IMAX", "IMAX 3D", "4DX", "Dolby Atmos", "ScreenX"];
+var FILM_LANGUAGES = ["en", "es", "fr", "de", "ja", "ko", "zh", "hi", "te", "mi"];
+var genreSchema = z4.enum(GENRES);
+var filmFormatSchema = z4.enum(FILM_FORMATS);
+var filmLanguageSchema = z4.enum(FILM_LANGUAGES);
+var ratingSchema = z4.object({
+  classification: z4.string(),
+  description: z4.string().optional()
+});
+var castMemberSchema = z4.object({
+  name: z4.string(),
+  role: z4.string().optional()
+});
+var crewMemberSchema = z4.object({
+  name: z4.string(),
+  department: z4.string(),
+  job: z4.string()
+});
+var filmRatingSchema = z4.object({
+  source: z4.string(),
+  score: z4.string(),
+  outOf: z4.string().optional()
+});
+var filmSchema = z4.object({
+  id: z4.string(),
+  title: z4.string(),
+  synopsis: z4.string(),
+  genres: z4.array(genreSchema),
+  runtime: z4.number().nonnegative(),
+  rating: ratingSchema,
+  releaseDate: z4.string(),
+  posterUrl: z4.string().optional(),
+  trailerUrl: z4.string().optional(),
+  cast: z4.array(castMemberSchema),
+  director: z4.string(),
+  distributor: z4.string().optional(),
+  isNowShowing: z4.boolean(),
+  isComingSoon: z4.boolean()
+});
+var filmDetailSchema = filmSchema.extend({
+  crew: z4.array(crewMemberSchema),
+  ratings: z4.array(filmRatingSchema),
+  formats: z4.array(filmFormatSchema),
+  languages: z4.array(filmLanguageSchema),
+  originalTitle: z4.string().optional(),
+  productionCountries: z4.array(z4.string()).optional(),
+  budget: z4.number().optional(),
+  boxOffice: z4.number().optional(),
+  website: z4.string().optional()
+});
+var filmSearchFilterSchema = z4.object({
+  siteId: z4.string().optional(),
+  genre: genreSchema.optional(),
+  query: z4.string().optional(),
+  nowShowing: z4.boolean().optional(),
+  comingSoon: z4.boolean().optional(),
+  limit: z4.number().int().positive().optional(),
+  offset: z4.number().int().nonnegative().optional(),
+  ratingClassification: z4.string().optional(),
+  format: filmFormatSchema.optional(),
+  language: filmLanguageSchema.optional(),
+  releaseDateFrom: z4.string().optional(),
+  releaseDateTo: z4.string().optional(),
+  minRuntime: z4.number().nonnegative().optional(),
+  maxRuntime: z4.number().nonnegative().optional(),
+  sortBy: z4.enum(["title", "releaseDate", "runtime", "popularity"]).optional(),
+  sortOrder: z4.enum(["asc", "desc"]).optional()
+});
+
+// src/resources/films.ts
+import { z as z5 } from "zod";
+var FilmsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Parse and validate a raw film response from the API.
+   * Throws a ZodError if the response doesn't match the expected shape.
+   */
+  parseFilm(data) {
+    return filmSchema.parse(data);
+  }
+  /**
+   * Parse and validate an array of films from the API.
+   */
+  parseFilms(data) {
+    return z5.array(filmSchema).parse(data);
+  }
+  /**
+   * Parse and validate a full film detail response.
+   */
+  parseFilmDetail(data) {
+    return filmDetailSchema.parse(data);
+  }
+  /**
+   * List films currently showing at a given site (or across all sites).
+   *
+   * @param filters - Optional site filter
+   * @returns Array of films currently in cinemas
+   */
+  async nowShowing(filters) {
+    const params = filters?.siteId ? { siteId: filters.siteId } : void 0;
+    const data = await this.http.get("/ocapi/v1/films/now-showing", { params });
+    return this.parseFilms(data);
+  }
+  /**
+   * List films coming soon — announced but not yet in cinemas.
+   *
+   * @param filters - Optional site filter
+   * @returns Array of upcoming films
+   */
+  async comingSoon(filters) {
+    const params = filters?.siteId ? { siteId: filters.siteId } : void 0;
+    const data = await this.http.get("/ocapi/v1/films/coming-soon", { params });
+    return this.parseFilms(data);
+  }
+  /**
+   * Retrieve a film by its unique identifier.
+   *
+   * @param filmId - The UUID of the film
+   * @returns The base film record
+   */
+  async get(filmId) {
+    const data = await this.http.get(`/ocapi/v1/films/${filmId}`);
+    return this.parseFilm(data);
+  }
+  /**
+   * Retrieve full film detail including cast, crew, ratings, formats, and languages.
+   *
+   * This returns the extended `FilmDetail` type with nested crew arrays,
+   * multiple rating sources (IMDB, Rotten Tomatoes, Metacritic), available
+   * screening formats, and language options.
+   *
+   * @param filmId - The UUID of the film
+   * @returns Full film detail with cast, crew, and ratings
+   */
+  async getDetail(filmId) {
+    const data = await this.http.get(`/ocapi/v1/films/${filmId}/detail`);
+    return this.parseFilmDetail(data);
+  }
+  /**
+   * Search films with basic filters.
+   *
+   * @throws {TheatricalError} When the API returns an error response
+   * @throws {z.ZodError} When the response fails schema validation
+   * @param filters - Genre, query string, site, and showing status filters
+   * @returns Array of matching films
+   */
+  async search(filters) {
+    const params = {};
+    if (filters.siteId) params.siteId = filters.siteId;
+    if (filters.genre) params.genre = filters.genre;
+    if (filters.query) params.query = filters.query;
+    if (filters.nowShowing !== void 0) params.nowShowing = filters.nowShowing;
+    if (filters.comingSoon !== void 0) params.comingSoon = filters.comingSoon;
+    const data = await this.http.get("/ocapi/v1/films", { params });
+    return this.parseFilms(data);
+  }
+  /**
+   * Advanced film search with extended filters.
+   *
+   * Supports filtering by format (IMAX, 3D, Dolby Atmos), language,
+   * rating classification, runtime range, release date range, and sorting.
+   *
+   * @param filters - Extended search filters including format, language, runtime range, sorting
+   * @returns Array of matching films
+   */
+  async advancedSearch(filters) {
+    const params = {};
+    if (filters.siteId) params.siteId = filters.siteId;
+    if (filters.genre) params.genre = filters.genre;
+    if (filters.query) params.query = filters.query;
+    if (filters.nowShowing !== void 0) params.nowShowing = String(filters.nowShowing);
+    if (filters.comingSoon !== void 0) params.comingSoon = String(filters.comingSoon);
+    if (filters.limit !== void 0) params.limit = String(filters.limit);
+    if (filters.offset !== void 0) params.offset = String(filters.offset);
+    if (filters.ratingClassification) params.ratingClassification = filters.ratingClassification;
+    if (filters.format) params.format = filters.format;
+    if (filters.language) params.language = filters.language;
+    if (filters.releaseDateFrom) params.releaseDateFrom = filters.releaseDateFrom;
+    if (filters.releaseDateTo) params.releaseDateTo = filters.releaseDateTo;
+    if (filters.minRuntime !== void 0) params.minRuntime = String(filters.minRuntime);
+    if (filters.maxRuntime !== void 0) params.maxRuntime = String(filters.maxRuntime);
+    if (filters.sortBy) params.sortBy = filters.sortBy;
+    if (filters.sortOrder) params.sortOrder = filters.sortOrder;
+    const data = await this.http.get("/ocapi/v1/films/search", { params });
+    return this.parseFilms(data);
+  }
+};
+
+// src/types/order.ts
+import { z as z6 } from "zod";
+var orderStatusSchema = z6.enum([
+  "draft",
+  "pending",
+  "held",
+  "confirmed",
+  "completed",
+  "cancelled",
+  "refunded"
+]);
+var ticketSchema = z6.object({
+  id: z6.string(),
+  type: z6.string(),
+  seatId: z6.string(),
+  seatLabel: z6.string(),
+  price: z6.number().nonnegative(),
+  discount: z6.number().nonnegative().optional()
+});
+var orderItemSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  category: z6.string(),
+  quantity: z6.number().int().positive(),
+  unitPrice: z6.number().nonnegative(),
+  totalPrice: z6.number().nonnegative()
+});
+var orderSchema = z6.object({
+  id: z6.string(),
+  sessionId: z6.string(),
+  status: orderStatusSchema,
+  tickets: z6.array(ticketSchema),
+  items: z6.array(orderItemSchema),
+  subtotal: z6.number().nonnegative(),
+  tax: z6.number().nonnegative(),
+  discount: z6.number().nonnegative(),
+  total: z6.number().nonnegative(),
+  currency: z6.string().length(3),
+  loyaltyMemberId: z6.string().optional(),
+  loyaltyPointsEarned: z6.number().int().nonnegative().optional(),
+  loyaltyPointsRedeemed: z6.number().int().nonnegative().optional(),
+  createdAt: z6.string(),
+  updatedAt: z6.string().optional(),
+  heldAt: z6.string().optional(),
+  heldUntil: z6.string().optional(),
+  confirmedAt: z6.string().optional(),
+  completedAt: z6.string().optional(),
+  cancelledAt: z6.string().optional(),
+  refundedAt: z6.string().optional()
+});
+var orderHistoryFilterSchema = z6.object({
+  status: orderStatusSchema.optional(),
+  since: z6.string().optional(),
+  until: z6.string().optional(),
+  limit: z6.number().int().positive().max(100).optional(),
+  cursor: z6.string().optional()
+});
+
+// src/types/pagination.ts
+import { z as z7 } from "zod";
+var paginationParamsSchema = z7.object({
+  limit: z7.number().int().positive().max(500).optional(),
+  cursor: z7.string().optional(),
+  offset: z7.number().int().nonnegative().optional()
+}).refine(
+  (data) => !(data.cursor && data.offset !== void 0),
+  { message: "Cannot specify both cursor and offset \u2014 choose one pagination strategy" }
+);
+var paginatedResponseSchema = z7.object({
+  data: z7.array(z7.unknown()),
+  total: z7.number().int().nonnegative(),
+  hasMore: z7.boolean(),
+  nextCursor: z7.string().optional(),
+  nextOffset: z7.number().int().nonnegative().optional(),
+  strategy: z7.enum(["cursor", "offset"])
+});
+
+// src/resources/orders.ts
+import { z as z8 } from "zod";
+var OrdersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Parse and validate a raw order response from the API.
+   * Throws a ZodError if the response doesn't match the expected shape.
+   */
+  parseOrder(data) {
+    return orderSchema.parse(data);
+  }
+  /**
+   * Parse and validate a paginated order response from the API.
+   */
+  parsePaginatedOrders(data) {
+    const envelopeSchema = paginatedResponseSchema.extend({
+      data: z8.array(orderSchema)
+    });
+    const parsed = envelopeSchema.parse(data);
+    return parsed;
+  }
+  /**
+   * Create a new draft order for a session.
+   *
+   * @throws {TheatricalError} When the API returns an error response
+   * @throws {z.ZodError} When the response fails schema validation
+   * @param input - Session ID, initial tickets, optional F   * @param input - Session ID, initial tickets, optional F&B items, optional loyalty memberB items, optional loyalty member
+   * @returns The newly created order in 'draft' status
+   */
+  async create(input) {
+    const data = await this.http.post("/ocapi/v1/orders", { body: input });
+    return this.parseOrder(data);
+  }
+  /**
+   * Retrieve an order by its unique identifier.
+   *
+   * @param orderId - The UUID of the order to retrieve
+   */
+  async get(orderId) {
+    const data = await this.http.get(`/ocapi/v1/orders/${orderId}`);
+    return this.parseOrder(data);
+  }
+  /**
+   * Set tickets on a draft order. Each ticket specifies a seat and ticket type.
+   * The Vista OCAPI replaces all existing tickets — pass the full desired set in one call.
+   *
+   * @param orderId - The UUID of the draft order
+   * @param input - Tickets to set (replaces any previously assigned tickets)
+   * @returns The updated order with the new ticket set
+   */
+  async addTickets(orderId, input) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/tickets`, { body: input });
+    return this.parseOrder(data);
+  }
+  /**
+   * Add concession or merchandise items to an order.
+   * F&B items can be added to orders in 'draft' or 'pending' status.
+   *
+   * @param orderId - The UUID of the order
+   * @param input - Items to add (menuItemId + quantity pairs)
+   * @returns The updated order with new items included
+   */
+  async addItems(orderId, input) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/items`, { body: input });
+    return this.parseOrder(data);
+  }
+  /**
+   * Confirm an order, transitioning it from 'pending' to 'confirmed'.
+   * This locks in the seat selection and pricing.
+   *
+   * @param orderId - The UUID of the order to confirm
+   */
+  async confirm(orderId) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/confirm`);
+    return this.parseOrder(data);
+  }
+  /**
+   * Cancel an order. Can be applied to 'pending' or 'confirmed' orders.
+   * Releases any held seats back to the pool.
+   *
+   * @param orderId - The UUID of the order to cancel
+   */
+  async cancel(orderId) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/cancel`);
+    return this.parseOrder(data);
+  }
+  /**
+   * Apply a loyalty membership discount to an order.
+   * Links the member to the order and optionally redeems loyalty points
+   * for a discount on the total.
+   *
+   * @param orderId - The UUID of the order
+   * @param input - Loyalty member ID and optional points to redeem
+   * @returns The updated order with loyalty discount applied
+   */
+  async applyLoyalty(orderId, input) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/loyalty`, { body: input });
+    return this.parseOrder(data);
+  }
+  /**
+   * Request a refund for a confirmed or completed order.
+   * Triggers the refund workflow in Vista's payment system.
+   *
+   * @param orderId - The UUID of the order to refund
+   */
+  async refund(orderId) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/refund`);
+    return this.parseOrder(data);
+  }
+  /**
+   * Mark a confirmed order as completed (e.g., after the screening).
+   *
+   * @param orderId - The UUID of the confirmed order
+   */
+  async complete(orderId) {
+    const data = await this.http.post(`/ocapi/v1/orders/${orderId}/complete`);
+    return this.parseOrder(data);
+  }
+  /**
+   * Retrieve order history for a loyalty member.
+   * Returns a paginated list of orders, newest first.
+   *
+   * @param memberId - The loyalty member's unique identifier
+   * @param filter - Optional filters for status, date range, and pagination
+   */
+  async history(memberId, filter) {
+    const params = {};
+    if (filter?.status) params.status = filter.status;
+    if (filter?.since) params.since = filter.since;
+    if (filter?.until) params.until = filter.until;
+    if (filter?.limit) params.limit = String(filter.limit);
+    if (filter?.cursor) params.cursor = filter.cursor;
+    const data = await this.http.get(`/ocapi/v1/members/${memberId}/orders`, { params });
+    return this.parsePaginatedOrders(data);
+  }
+};
+
+// src/resources/loyalty.ts
+var LoyaltyResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Fetch a loyalty member by their unique ID.
+   *
+   * @param memberId - Vista loyalty member identifier
+   * @throws {TheatricalError} When the API returns an error response
+   */
+  async getMember(memberId) {
+    return this.http.get(`/ocapi/v1/loyalty/members/${memberId}`);
+  }
+  /**
+   * Authenticate a member using their email address and password (cookie-based
+   * session). Returns the authenticated member record on success.
+   *
+   * @param email    - Member's registered email
+   * @param password - Account password (transmitted over TLS)
+   */
+  async authenticate(email, password) {
+    return this.http.post("/ocapi/v1/loyalty/authenticate", {
+      body: { email, password }
+    });
+  }
+  /**
+   * Return the current redeemable points balance for a member.
+   *
+   * @param memberId - Vista loyalty member identifier
+   */
+  async getPointsBalance(memberId) {
+    return this.http.get(
+      `/ocapi/v1/loyalty/members/${memberId}/points`
+    );
+  }
+  /**
+   * Retrieve a paginated transaction history for a member.
+   *
+   * @param memberId - Vista loyalty member identifier
+   * @param filter   - Optional date range, type, and pagination filters
+   */
+  async getHistory(memberId, filter) {
+    return this.http.get(
+      `/ocapi/v1/loyalty/members/${memberId}/history`,
+      { params: filter }
+    );
+  }
+  /**
+   * List available redemption options for the loyalty program.
+   * Options are filtered to those the member is eligible for based on their
+   * tier and current points balance.
+   *
+   * @param memberId - Vista loyalty member identifier
+   */
+  async listRedemptionOptions(memberId) {
+    return this.http.get(
+      `/ocapi/v1/loyalty/members/${memberId}/redemptions`
+    );
+  }
+  /**
+   * Redeem points against a catalog option for a member.
+   * Deducts points from the member's balance and applies the benefit.
+   *
+   * @param memberId - Vista loyalty member identifier
+   * @param input    - Redemption option, optional order linkage, and quantity
+   */
+  async redeemPoints(memberId, input) {
+    return this.http.post(
+      `/ocapi/v1/loyalty/members/${memberId}/redeem`,
+      { body: input }
+    );
+  }
+};
+
+// src/resources/subscriptions.ts
+var SubscriptionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all available subscription plans for a Vista site.
+   *
+   * Returns only plans that are available for new subscriptions unless
+   * {@link includeUnavailable} is set to true (useful for admin UIs).
+   *
+   * @param siteId            - Vista site identifier to scope plans to
+   * @param includeUnavailable - When true, include discontinued plans
+   */
+  async listPlans(siteId, includeUnavailable) {
+    return this.http.get("/ocapi/v1/subscriptions/plans", {
+      params: {
+        ...siteId ? { siteId } : {},
+        ...includeUnavailable ? { includeUnavailable: true } : {}
+      }
+    });
+  }
+  /**
+   * Retrieve the active (or most recent) subscription for a member.
+   *
+   * @param memberId - Vista loyalty member identifier
+   */
+  async getMemberSubscription(memberId) {
+    return this.http.get(`/ocapi/v1/subscriptions/members/${memberId}`);
+  }
+  /**
+   * Get usage statistics for a member's subscription in the current billing period.
+   *
+   * Returns booking counts, remaining allowance, and per-benefit usage.
+   * Use this before allowing a booking to check whether the member has
+   * bookings remaining under their plan.
+   *
+   * @param memberId - Vista loyalty member identifier
+   */
+  async getUsage(memberId) {
+    return this.http.get(
+      `/ocapi/v1/subscriptions/members/${memberId}/usage`
+    );
+  }
+  /**
+   * Check whether a member is eligible to use a specific benefit.
+   *
+   * Returns true if the benefit is included in their plan, is currently active,
+   * and the member has remaining uses for the current period.
+   *
+   * @param memberId  - Vista loyalty member identifier
+   * @param benefitId - Benefit ID from the plan's benefits array
+   */
+  async checkBenefitEligibility(memberId, benefitId) {
+    return this.http.get(
+      `/ocapi/v1/subscriptions/members/${memberId}/benefits/${benefitId}/eligibility`
+    );
+  }
+  /**
+   * Suspend a member's subscription temporarily.
+   *
+   * The subscription status transitions to `paused`. Billing is paused for the
+   * suspension period. If {@link SuspendSubscriptionInput.resumeDate} is
+   * provided, the subscription will auto-resume on that date; otherwise it must
+   * be manually resumed.
+   *
+   * @param memberId - Vista loyalty member identifier
+   * @param input    - Optional resume date and reason
+   */
+  async suspend(memberId, input) {
+    return this.http.post(
+      `/ocapi/v1/subscriptions/members/${memberId}/suspend`,
+      { body: input ?? {} }
+    );
+  }
+  /**
+   * Cancel a member's subscription.
+   *
+   * By default cancels at the end of the current billing period. Set
+   * {@link CancelSubscriptionInput.immediate} to `true` for an immediate
+   * cancellation with no refund.
+   *
+   * @param memberId - Vista loyalty member identifier
+   * @param input    - Whether to cancel immediately and optional reason
+   */
+  async cancel(memberId, input) {
+    return this.http.post(
+      `/ocapi/v1/subscriptions/members/${memberId}/cancel`,
+      { body: input ?? {} }
+    );
+  }
+};
+
+// src/resources/pricing.ts
+var PricingResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List available ticket types for a session.
+   *
+   * @param sessionId - The Vista session ID.
+   * @param filter - Optional filter params (category, availableOnly).
+   */
+  async ticketTypes(sessionId, filter) {
+    return this.http.get(`/ocapi/v1/sessions/${sessionId}/ticket-types`, {
+      params: { ...filter }
+    });
+  }
+  /**
+   * Calculate the price for a ticket type and quantity.
+   *
+   * Returns an itemised {@link PriceBreakdown} including base price, discounts,
+   * surcharges, and tax. The breakdown reflects the caller's Vista site tax
+   * configuration (inclusive vs exclusive).
+   *
+   * @param sessionId - The Vista session ID.
+   * @param ticketTypeId - Ticket type to price.
+   * @param quantity - Number of tickets (default 1).
+   */
+  async calculate(sessionId, ticketTypeId, quantity = 1) {
+    return this.http.get(`/ocapi/v1/pricing/calculate`, {
+      params: { sessionId, ticketTypeId, quantity }
+    });
+  }
+  /**
+   * Apply coupon codes and resolve loyalty-tier discounts.
+   *
+   * Validates each coupon code, stacks applicable discounts, and returns
+   * an updated {@link PriceBreakdown}. Invalid or expired codes are listed
+   * in the `rejected` array rather than throwing.
+   *
+   * @param input - Session, ticket type, quantity, coupon codes, and optional member ID.
+   */
+  async applyCoupons(input) {
+    return this.http.post(`/ocapi/v1/pricing/apply-coupons`, { body: input });
+  }
+};
+
+// src/resources/food-and-beverage.ts
+var FoodAndBeverageResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List menu items for a site, with optional filtering.
+   *
+   * Results include dietary tags and customisation options. Use `filter.dietary`
+   * to surface only vegan / gluten-free items. Use `filter.preOrderOnly` when
+   * building a pre-order flow tied to a session.
+   *
+   * @param siteId - The Vista site ID.
+   * @param filter - Optional filter (dietary, category, availability).
+   */
+  async menu(siteId, filter) {
+    return this.http.get(`/ocapi/v1/sites/${siteId}/menu`, {
+      params: { ...filter, dietary: filter?.dietary?.join(",") }
+    });
+  }
+  /**
+   * List available menu categories for a site.
+   *
+   * Categories define the candy-bar section groupings (popcorn, drinks,
+   * combos, snacks). Ordered by `displayOrder` ascending.
+   *
+   * @param siteId - The Vista site ID.
+   */
+  async categories(siteId) {
+    return this.http.get(`/ocapi/v1/sites/${siteId}/menu/categories`);
+  }
+  /**
+   * Fetch full detail for a single menu item.
+   *
+   * Includes customisation options (size, flavour) not always returned in
+   * the full menu list. Use this before presenting an add-to-order form.
+   *
+   * @param siteId - The Vista site ID.
+   * @param itemId - The menu item ID.
+   */
+  async itemDetail(siteId, itemId) {
+    return this.http.get(`/ocapi/v1/sites/${siteId}/menu/items/${itemId}`);
+  }
+  /**
+   * List combo deals available at a site.
+   *
+   * Combos are pre-configured bundles (e.g. "Large Popcorn + Large Drink").
+   * The `savings` field on each {@link ComboOffer} indicates the discount
+   * vs buying items individually — useful for upsell copy.
+   *
+   * @param siteId - The Vista site ID.
+   */
+  async combos(siteId) {
+    return this.http.get(`/ocapi/v1/sites/${siteId}/menu/combos`);
+  }
+  /**
+   * Add F&B items to an existing Vista order.
+   *
+   * Attaches concession items to a booking in progress. When adding
+   * pre-order items tied to a specific session, pass `input.sessionId`
+   * to enable collection-slot logic on the Vista side.
+   *
+   * Returns a confirmation with updated F&B subtotal for display.
+   *
+   * @param input - Order ID, items to add, optional session ID.
+   */
+  async addToOrder(input) {
+    return this.http.post(
+      `/ocapi/v1/orders/${input.orderId}/fnb`,
+      { body: input }
+    );
+  }
+};
+
+// src/http/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4,
+  jitter: true
+};
+function computeBackoffDelay(attempt, config) {
+  const exponential = Math.min(
+    config.baseDelay * Math.pow(2, attempt - 1),
+    config.maxDelay
+  );
+  if (!config.jitter) return exponential;
+  return Math.floor(exponential * (0.5 + Math.random() * 0.5));
+}
+
+// src/http/interceptors.ts
+async function runInterceptors(value, interceptors) {
+  let current = value;
+  for (const interceptor of interceptors) {
+    current = await interceptor(current);
+  }
+  return current;
+}
+
+// src/http/client.ts
+var TheatricalHTTPClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async get(path, options) {
+    return this.request({ ...options, method: "GET" }, path);
+  }
+  async post(path, options) {
+    return this.request({ ...options, method: "POST" }, path);
+  }
+  async put(path, options) {
+    return this.request({ ...options, method: "PUT" }, path);
+  }
+  async delete(path, options) {
+    return this.request({ ...options, method: "DELETE" }, path);
+  }
+  async request(options, path, attempt = 1) {
+    if (this.config.rateLimiter) {
+      await this.config.rateLimiter.waitForSlot();
+    }
+    const token = await this.config.tokenManager.getToken();
+    const url = this.buildUrl(path, options.params);
+    const requestId = this.generateRequestId();
+    if (this.config.debug) {
+      console.log(`[theatrical] ${options.method} ${url} (${requestId})`);
+    }
+    const serialisedBody = options.body ? JSON.stringify(options.body) : void 0;
+    let requestConfig = {
+      url,
+      method: options.method ?? "GET",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "X-Request-ID": requestId,
+        ...options.headers
+      },
+      body: serialisedBody
+    };
+    if (this.config.onRequest?.length) {
+      requestConfig = await runInterceptors(requestConfig, this.config.onRequest);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      let response = await fetch(requestConfig.url, {
+        method: requestConfig.method,
+        headers: requestConfig.headers,
+        body: requestConfig.body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        if (this.config.onResponse?.length) {
+          response = await runInterceptors(response, this.config.onResponse);
+        }
+        return await response.json();
+      }
+      if (response.status === 401) {
+        this.config.tokenManager.invalidate();
+        if (attempt <= 1) {
+          return this.request(options, path, attempt + 1);
+        }
+      }
+      const error = await parseErrorResponse(response, requestConfig.url);
+      if ((error instanceof RateLimitError || error instanceof ServerError) && attempt <= this.config.maxRetries) {
+        const retryConfig = this.config.retry ?? { ...DEFAULT_RETRY_CONFIG, maxRetries: this.config.maxRetries };
+        const delayMs = error instanceof RateLimitError ? error.retryAfter * 1e3 : computeBackoffDelay(attempt, retryConfig);
+        await this.delay(delayMs);
+        return this.request(options, path, attempt + 1);
+      }
+      throw error;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof TheatricalError) {
+        throw error;
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new TheatricalError("Request timed out", 408, void 0, requestId);
+      }
+      throw new TheatricalError(
+        `Network error: ${error.message}`,
+        0,
+        void 0,
+        requestId
+      );
+    }
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.config.baseUrl);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  generateRequestId() {
+    return `th_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/auth/gas-client.ts
+var GASClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Request a new JWT token from the Global Authentication Service
+   */
+  async requestToken() {
+    const response = await fetch(`${this.config.authUrl}/oauth/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        grant_type: "client_credentials",
+        api_key: this.config.apiKey
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`GAS authentication failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      accessToken: data.access_token,
+      tokenType: data.token_type ?? "Bearer",
+      expiresIn: data.expires_in ?? 3600,
+      issuedAt: Date.now()
+    };
+  }
+};
+
+// src/auth/token-manager.ts
+var TokenManager = class {
+  gasClient;
+  currentToken = null;
+  refreshPromise = null;
+  /** Buffer before expiry to trigger refresh (5 minutes) */
+  expiryBuffer = 5 * 60 * 1e3;
+  constructor(gasClient) {
+    this.gasClient = gasClient;
+  }
+  /**
+   * Get a valid access token, refreshing if necessary.
+   * Deduplicates concurrent refresh requests.
+   */
+  async getToken() {
+    if (this.currentToken && !this.isExpired(this.currentToken)) {
+      return this.currentToken.accessToken;
+    }
+    if (!this.refreshPromise) {
+      this.refreshPromise = this.refresh();
+    }
+    try {
+      const token = await this.refreshPromise;
+      return token.accessToken;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  /**
+   * Force a token refresh regardless of current token state
+   */
+  async refresh() {
+    const token = await this.gasClient.requestToken();
+    this.currentToken = token;
+    return token;
+  }
+  /**
+   * Check if a token is expired or within the expiry buffer
+   */
+  isExpired(token) {
+    const expiresAt = token.issuedAt + token.expiresIn * 1e3;
+    return Date.now() >= expiresAt - this.expiryBuffer;
+  }
+  /**
+   * Clear the current token (e.g., on 401 response)
+   */
+  invalidate() {
+    this.currentToken = null;
+  }
+};
+
+// src/http/rate-limiter.ts
+var DEFAULT_RATE_LIMITER_CONFIG = {
+  maxRequests: 60,
+  windowMs: 6e4
+};
+var RateLimiter = class {
+  config;
+  timestamps = [];
+  /**
+   * Creates a new RateLimiter.
+   * @param config - Limits and window size. Defaults to {@link DEFAULT_RATE_LIMITER_CONFIG}.
+   */
+  constructor(config = DEFAULT_RATE_LIMITER_CONFIG) {
+    this.config = config;
+  }
+  /**
+   * Waits until a request slot is available within the current window,
+   * records the request timestamp, and resolves.
+   *
+   * Callers `await` this before making an HTTP request. If the limit has been
+   * reached, the call suspends until the oldest in-window request expires.
+   *
+   * @returns Promise that resolves when it is safe to proceed with a request
+   */
+  async waitForSlot() {
+    for (; ; ) {
+      const now = Date.now();
+      const windowStart = now - this.config.windowMs;
+      while (this.timestamps.length > 0 && this.timestamps[0] < windowStart) {
+        this.timestamps.shift();
+      }
+      if (this.timestamps.length < this.config.maxRequests) {
+        this.timestamps.push(now);
+        return;
+      }
+      const oldestTs = this.timestamps[0];
+      const waitMs = oldestTs + this.config.windowMs - now + 1;
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+    }
+  }
+  /**
+   * Returns the number of requests recorded within the current rolling window.
+   * Useful for diagnostics and integration tests.
+   */
+  get activeCount() {
+    const windowStart = Date.now() - this.config.windowMs;
+    return this.timestamps.filter((ts) => ts >= windowStart).length;
+  }
+  /**
+   * Clears all recorded timestamps, resetting the limiter to a clean state.
+   * Primarily intended for use in tests.
+   */
+  reset() {
+    this.timestamps.length = 0;
+  }
+};
+
+// src/mock/fixtures.ts
+var DEFAULT_MOCK_RESPONSES = {
+  // Films
+  "/ocapi/v1/films/now-showing": [
+    {
+      id: "film_holdovers_2023",
+      title: "The Holdovers",
+      synopsis: "A cranky history teacher is forced to stay on campus over the holidays with a troubled student.",
+      genres: ["drama", "comedy"],
+      runtime: 133,
+      rating: { classification: "M", description: "Offensive language" },
+      releaseDate: "2026-03-14",
+      posterUrl: "https://image.tmdb.org/t/p/w500/VHSEkBNbAoEGfBmiGGOhEHaGMsD.jpg",
+      cast: [{ name: "Paul Giamatti", role: "Paul Hunham" }, { name: "Dominic Sessa", role: "Angus Tully" }],
+      director: "Alexander Payne",
+      isNowShowing: true,
+      isComingSoon: false
+    },
+    {
+      id: "film_poor_things_2023",
+      title: "Poor Things",
+      synopsis: "The incredible tale about the fantastical evolution of Bella Baxter.",
+      genres: ["comedy", "drama", "sci-fi"],
+      runtime: 141,
+      rating: { classification: "R18", description: "Graphic sexual content, offensive language" },
+      releaseDate: "2026-02-01",
+      posterUrl: "https://image.tmdb.org/t/p/w500/kCGlIMHnOm8JPXIhMLGUMEFbV4B.jpg",
+      cast: [{ name: "Emma Stone", role: "Bella Baxter" }, { name: "Mark Ruffalo", role: "Duncan Wedderburn" }],
+      director: "Yorgos Lanthimos",
+      isNowShowing: true,
+      isComingSoon: false
+    }
+  ],
+  "/ocapi/v1/films/coming-soon": [
+    {
+      id: "film_dune2_2024",
+      title: "Dune: Part Two",
+      synopsis: "Paul Atreides unites with Chani and the Fremen while seeking revenge against the conspirators.",
+      genres: ["sci-fi", "adventure"],
+      runtime: 166,
+      rating: { classification: "M", description: "Violence" },
+      releaseDate: "2026-05-01",
+      posterUrl: "https://image.tmdb.org/t/p/w500/czembW0Rk1Ke7lCJGahbOhdCuhx.jpg",
+      cast: [{ name: "Timoth\xE9e Chalamet", role: "Paul Atreides" }, { name: "Zendaya", role: "Chani" }],
+      director: "Denis Villeneuve",
+      isNowShowing: false,
+      isComingSoon: true
+    }
+  ],
+  "/ocapi/v1/films/:id": {
+    id: "film_holdovers_2023",
+    title: "The Holdovers",
+    synopsis: "A cranky history teacher is forced to stay on campus over the holidays with a troubled student.",
+    genres: ["drama", "comedy"],
+    runtime: 133,
+    rating: { classification: "M", description: "Offensive language" },
+    releaseDate: "2026-03-14",
+    posterUrl: "https://image.tmdb.org/t/p/w500/VHSEkBNbAoEGfBmiGGOhEHaGMsD.jpg",
+    cast: [{ name: "Paul Giamatti", role: "Paul Hunham" }],
+    director: "Alexander Payne",
+    crew: [{ name: "Alexander Payne", department: "Directing", job: "Director" }],
+    ratings: [{ source: "TMDB", score: "7.9", outOf: "10" }],
+    formats: ["2D"],
+    languages: ["en"],
+    isNowShowing: true,
+    isComingSoon: false
+  },
+  // Sessions
+  "/ocapi/v1/sessions": {
+    sessions: [
+      {
+        id: "ses_roxy_holdovers_20260427_1915",
+        filmId: "film_holdovers_2023",
+        filmTitle: "The Holdovers",
+        siteId: "site_roxy_wellington",
+        screenId: "scr_roxy_3",
+        screenName: "Screen 3",
+        startTime: "2026-04-27T19:15:00+12:00",
+        endTime: "2026-04-27T21:28:00+12:00",
+        format: "2D",
+        isBookable: true,
+        isSoldOut: false,
+        seatsAvailable: 74,
+        seatsTotal: 120,
+        priceFrom: 19.5,
+        attributes: {}
+      },
+      {
+        id: "ses_roxy_poor_things_20260427_2000",
+        filmId: "film_poor_things_2023",
+        filmTitle: "Poor Things",
+        siteId: "site_roxy_wellington",
+        screenId: "scr_roxy_2",
+        screenName: "Screen 2 \u2014 IMAX",
+        startTime: "2026-04-27T20:00:00+12:00",
+        endTime: "2026-04-27T22:21:00+12:00",
+        format: "IMAX",
+        isBookable: true,
+        isSoldOut: false,
+        seatsAvailable: 28,
+        seatsTotal: 140,
+        priceFrom: 25,
+        attributes: {}
+      }
+    ],
+    total: 2,
+    hasMore: false
+  },
+  "/ocapi/v1/sessions/:id": {
+    id: "ses_roxy_holdovers_20260427_1915",
+    filmId: "film_holdovers_2023",
+    filmTitle: "The Holdovers",
+    siteId: "site_roxy_wellington",
+    screenId: "scr_roxy_3",
+    screenName: "Screen 3",
+    startTime: "2026-04-27T19:15:00+12:00",
+    endTime: "2026-04-27T21:28:00+12:00",
+    format: "2D",
+    isBookable: true,
+    isSoldOut: false,
+    seatsAvailable: 74,
+    seatsTotal: 120,
+    priceFrom: 19.5,
+    attributes: {}
+  },
+  "/ocapi/v1/sessions/:id/seat-plan": {
+    sessionId: "ses_roxy_holdovers_20260427_1915",
+    screenName: "Screen 3",
+    seats: Array.from(
+      { length: 10 },
+      (_, row) => Array.from({ length: 12 }, (_2, col) => ({
+        id: `seat_${String.fromCharCode(65 + row)}${col + 1}`,
+        row: String.fromCharCode(65 + row),
+        number: col + 1,
+        status: row < 3 && col > 8 ? "taken" : "available",
+        x: col,
+        y: row,
+        type: row < 2 ? "premium" : "standard",
+        isAccessible: false
+      }))
+    ).flat(),
+    rowCount: 10,
+    screenPosition: "top",
+    availableCount: 74,
+    totalCount: 120
+  },
+  // Sites
+  "/ocapi/v1/sites": [
+    {
+      id: "site_roxy_wellington",
+      name: "Roxy Cinema",
+      address: { line1: "5 Park Road", city: "Wellington", postalCode: "6022", country: "NZ" },
+      location: { latitude: -41.319, longitude: 174.8127 },
+      screens: [
+        { id: "scr_roxy_1", name: "Screen 1", seatCount: 80, formats: ["2D"], isAccessible: true },
+        { id: "scr_roxy_2", name: "Screen 2 \u2014 IMAX", seatCount: 140, formats: ["IMAX", "2D"], isAccessible: true },
+        { id: "scr_roxy_3", name: "Screen 3", seatCount: 120, formats: ["2D", "3D"], isAccessible: true }
+      ],
+      config: { bookingLeadTime: 15, maxTicketsPerOrder: 8, loyaltyEnabled: true, fnbEnabled: true },
+      timezone: "Pacific/Auckland",
+      currency: "NZD",
+      isActive: true,
+      amenities: [
+        { id: "bar", label: "Bar" },
+        { id: "wheelchair", label: "Wheelchair Access" },
+        { id: "parking", label: "Free Parking" }
+      ]
+    }
+  ],
+  "/ocapi/v1/sites/:id": {
+    id: "site_roxy_wellington",
+    name: "Roxy Cinema",
+    address: { line1: "5 Park Road", city: "Wellington", postalCode: "6022", country: "NZ" },
+    location: { latitude: -41.319, longitude: 174.8127 },
+    screens: [
+      { id: "scr_roxy_1", name: "Screen 1", seatCount: 80, formats: ["2D"], isAccessible: true }
+    ],
+    config: { bookingLeadTime: 15, maxTicketsPerOrder: 8, loyaltyEnabled: true, fnbEnabled: true },
+    timezone: "Pacific/Auckland",
+    currency: "NZD",
+    isActive: true
+  },
+  // Orders
+  "/ocapi/v1/orders": {
+    id: "ord_mock_001",
+    status: "draft",
+    siteId: "site_roxy_wellington",
+    sessionId: "ses_roxy_holdovers_20260427_1915",
+    tickets: [],
+    items: [],
+    pricing: { subtotal: 0, tax: 0, discounts: 0, total: 0 },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  },
+  // Loyalty
+  "/ocapi/v1/loyalty/members/:id": {
+    id: "mem_hemi_walker_5528",
+    email: "hemi.walker@example.co.nz",
+    firstName: "Hemi",
+    lastName: "Walker",
+    tier: {
+      id: "tier_gold",
+      name: "Gold",
+      level: 3,
+      benefits: ["10% off all tickets", "Free large popcorn monthly", "Priority booking"],
+      pointsThreshold: 5e3
+    },
+    points: 2840,
+    lifetimePoints: 8640,
+    memberSince: "2024-01-15",
+    active: true
+  }
+};
+
+// src/mock/mock-http-adapter.ts
+var MockHTTPAdapter = class {
+  responses;
+  constructor(overrides) {
+    this.responses = { ...DEFAULT_MOCK_RESPONSES, ...overrides };
+  }
+  /** Normalise a concrete path to a pattern key by replacing segments that look like IDs. */
+  matchPattern(path) {
+    const cleanPath = path.split("?")[0];
+    return cleanPath.replace(/\/([a-z_]+-[a-z_\d-]+|\d+)(?=\/|$)/gi, "/:id");
+  }
+  lookup(path) {
+    if (this.responses[path] !== void 0) return this.responses[path];
+    const pattern = this.matchPattern(path);
+    if (this.responses[pattern] !== void 0) return this.responses[pattern];
+    return void 0;
+  }
+  async get(path) {
+    const data = this.lookup(path);
+    if (data === void 0) {
+      throw new NotFoundError(`Mock: no fixture for GET ${path}`, path.split("/").pop() ?? path);
+    }
+    return data;
+  }
+  async post(path, options) {
+    const data = this.lookup(path);
+    if (data !== void 0) return data;
+    if (path.includes("/orders")) {
+      return {
+        id: `ord_mock_${Date.now()}`,
+        status: "draft",
+        tickets: [],
+        items: [],
+        pricing: { subtotal: 0, tax: 0, discounts: 0, total: 0 },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...options?.body && typeof options.body === "object" ? options.body : {}
+      };
+    }
+    return {};
+  }
+  async put(path, options) {
+    const data = this.lookup(path);
+    if (data !== void 0) return data;
+    return { ...options?.body && typeof options.body === "object" ? options.body : {} };
+  }
+  async delete(path) {
+    return {};
+  }
+};
+
+// src/client.ts
+var ENVIRONMENT_URLS = {
+  sandbox: "https://api-sandbox.vista.co",
+  staging: "https://api-staging.vista.co",
+  production: "https://api.vista.co"
+};
+var _globalInstance;
+var TheatricalClient = class _TheatricalClient {
+  config;
+  httpClient;
+  tokenManager;
+  // Lazily initialised resource modules
+  _sessions;
+  _sites;
+  _films;
+  _orders;
+  _loyalty;
+  _subscriptions;
+  _pricing;
+  _fnb;
+  /**
+   * Constructs a TheatricalClient with validated configuration.
+   *
+   * Throws `ValidationError` immediately if config is invalid.
+   *
+   * @param config - SDK configuration
+   * @throws {ValidationError} if config fails schema validation
+   */
+  constructor(config) {
+    this.config = validateConfig(config);
+    const baseUrl = this.config.baseUrl ?? ENVIRONMENT_URLS[this.config.environment];
+    const gasClient = new GASClient({
+      apiKey: this.config.apiKey,
+      authUrl: "https://auth.moviexchange.com"
+    });
+    this.tokenManager = new TokenManager(gasClient);
+    this.httpClient = new TheatricalHTTPClient({
+      baseUrl,
+      timeout: this.config.timeout,
+      maxRetries: this.config.maxRetries,
+      tokenManager: this.tokenManager,
+      debug: this.config.debug,
+      rateLimiter: new RateLimiter(DEFAULT_RATE_LIMITER_CONFIG)
+    });
+  }
+  /**
+   * Creates a new TheatricalClient instance.
+   *
+   * Equivalent to `new TheatricalClient(config)` but provided as a static
+   * factory for clarity in configuration-heavy setups.
+   *
+   * @param config - SDK configuration
+   * @returns New TheatricalClient instance
+   * @throws {ValidationError} if config fails schema validation
+   *
+   * @example
+   * ```typescript
+   * const client = TheatricalClient.create({
+   *   apiKey: process.env.THEATRICAL_API_KEY!,
+   *   environment: 'production',
+   *   timeout: 15_000,
+   * });
+   * ```
+   */
+  static create(config) {
+    return new _TheatricalClient(config);
+  }
+  /**
+   * Returns the global singleton TheatricalClient instance.
+   *
+   * Throws if no global instance has been configured via `setGlobal()`.
+   * Useful for applications that initialise the client once at startup and
+   * access it throughout without passing the instance around.
+   *
+   * @returns The global TheatricalClient instance
+   * @throws {Error} if setGlobal() has not been called
+   *
+   * @example
+   * ```typescript
+   * // At startup:
+   * TheatricalClient.setGlobal({ apiKey: 'key', environment: 'production' });
+   *
+   * // Anywhere in your app:
+   * const client = TheatricalClient.global();
+   * const films = await client.films.nowShowing({ siteId: 'roxy-wellington' });
+   * ```
+   */
+  static global() {
+    if (!_globalInstance) {
+      throw new Error(
+        "No global TheatricalClient configured. Call TheatricalClient.setGlobal(config) first."
+      );
+    }
+    return _globalInstance;
+  }
+  /**
+   * Configures the global singleton TheatricalClient instance.
+   *
+   * Replaces any existing global instance. Subsequent calls to
+   * `TheatricalClient.global()` will return this instance.
+   *
+   * @param config - SDK configuration
+   * @throws {ValidationError} if config fails schema validation
+   *
+   * @example
+   * ```typescript
+   * TheatricalClient.setGlobal({
+   *   apiKey: process.env.THEATRICAL_API_KEY!,
+   *   environment: 'production',
+   * });
+   * ```
+   */
+  static setGlobal(config) {
+    _globalInstance = new _TheatricalClient(config);
+  }
+  /**
+   * Resets the global singleton instance.
+   *
+   * Primarily intended for testing — allows tests to start with a clean slate.
+   *
+   * @example
+   * ```typescript
+   * afterEach(() => {
+   *   TheatricalClient.resetGlobal();
+   * });
+   * ```
+   */
+  static resetGlobal() {
+    _globalInstance = void 0;
+  }
+  /**
+   * Creates an offline mock client that returns pre-defined NZ cinema fixture data.
+   *
+   * Ideal for demos, prototypes, and evaluators without a Vista API key.
+   * The mock covers films, sessions, sites, orders, and loyalty endpoints.
+   *
+   * @param fixtureOverrides - Optional URL-keyed fixture map to replace specific responses
+   *
+   * @example
+   * ```typescript
+   * const client = import.meta.env.VITE_THEATRICAL_MOCK
+   *   ? TheatricalClient.createMock()
+   *   : TheatricalClient.create({ apiKey: process.env.THEATRICAL_API_KEY! });
+   * ```
+   *
+   * @see https://developer.vista.co
+   */
+  static createMock(fixtureOverrides) {
+    const instance = Object.create(_TheatricalClient.prototype);
+    instance.httpClient = new MockHTTPAdapter(fixtureOverrides);
+    instance.config = { apiKey: "mock", environment: "sandbox", timeout: 1e4, maxRetries: 0, debug: false };
+    instance.tokenManager = { getToken: async () => "mock-token", invalidate: () => {
+    } };
+    return instance;
+  }
+  /** Sessions — showtimes, availability, seat maps */
+  get sessions() {
+    if (!this._sessions) {
+      this._sessions = new SessionsResource(this.httpClient);
+    }
+    return this._sessions;
+  }
+  /** Sites — cinema locations, screens, configurations */
+  get sites() {
+    if (!this._sites) {
+      this._sites = new SitesResource(this.httpClient);
+    }
+    return this._sites;
+  }
+  /** Films — now showing, coming soon, search */
+  get films() {
+    if (!this._films) {
+      this._films = new FilmsResource(this.httpClient);
+    }
+    return this._films;
+  }
+  /** Orders — booking lifecycle: create, confirm, cancel */
+  get orders() {
+    if (!this._orders) {
+      this._orders = new OrdersResource(this.httpClient);
+    }
+    return this._orders;
+  }
+  /** Loyalty — member management, points, tiers */
+  get loyalty() {
+    if (!this._loyalty) {
+      this._loyalty = new LoyaltyResource(this.httpClient);
+    }
+    return this._loyalty;
+  }
+  /** Subscriptions — plans, member subscriptions */
+  get subscriptions() {
+    if (!this._subscriptions) {
+      this._subscriptions = new SubscriptionsResource(this.httpClient);
+    }
+    return this._subscriptions;
+  }
+  /** Pricing — ticket types, price calculations, tax handling */
+  get pricing() {
+    if (!this._pricing) {
+      this._pricing = new PricingResource(this.httpClient);
+    }
+    return this._pricing;
+  }
+  /** Food & Beverage — menus, ordering, dietary information */
+  get fnb() {
+    if (!this._fnb) {
+      this._fnb = new FoodAndBeverageResource(this.httpClient);
+    }
+    return this._fnb;
+  }
+};
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+var SDK_USER_AGENT = `theatrical-sdk/${SDK_VERSION} (Node.js)`;
+export {
+  AuthenticationError,
+  MockHTTPAdapter,
+  NotFoundError,
+  RateLimitError,
+  SDK_USER_AGENT,
+  SDK_VERSION,
+  ServerError,
+  TheatricalClient,
+  TheatricalError,
+  ValidationError
+};