@ticketboothapp/booking 0.1.10 → 0.1.12

package/src/lib/dependent-add-on-api.ts

@@ -0,0 +1,434 @@
+/**
+ * TicketBooth dependent add-on (DAP) APIs — booking-reference-first flow.
+ *
+ * Availability response may include primary booking itinerary (no last name typed by user):
+ *   `data.itineraryDisplay` or `data.primaryItineraryDisplay`
+ * and `data.primaryCustomerLastName` when stored on the booking.
+ * Same step shape as public booking `itineraryDisplay` (stepType, time, place, label).
+ *
+ * Itinerary-aware slots (client + recommended server behavior):
+ *   For each `arrive` → next `depart` pair, treat [arriveTime, departTime] as an on-site
+ *   window. Only offer slots fully contained in at least one window for the trip day.
+ *   This module filters the GET response when an itinerary is present (see
+ *   `filterSlotsByPrimaryItineraryWindows`). TicketBooth should apply the same rules when
+ *   building offerings so capacity and pricing stay authoritative.
+ */
+
+import { ENV } from '@/lib/env';
+import {
+  filterDapSlotsToPrimaryItineraryWindows,
+  normalizeDapItinerarySteps,
+  type DapItineraryStep,
+} from '@/lib/dap-itinerary-preview';
+
+export type { DapItineraryStep };
+
+const API_BASE = ENV.API_URL;
+
+function getAuthHeaders(): Record<string, string> {
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (ENV.BASIC_AUTH) {
+    headers['Authorization'] = `Basic ${ENV.BASIC_AUTH}`;
+  }
+  return headers;
+}
+
+async function parseJsonSafely(res: Response): Promise<unknown> {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+interface ApiErrorPayload {
+  errorCode?: string;
+  errorMessage?: string;
+  error?: string;
+}
+
+function isApiErrorPayload(value: unknown): value is ApiErrorPayload {
+  return typeof value === 'object' && value !== null;
+}
+
+function messageFromPayload(payload: unknown, fallback: string): string {
+  if (isApiErrorPayload(payload)) {
+    return payload.errorMessage || payload.error || fallback;
+  }
+  return fallback;
+}
+
+function pickStr(obj: Record<string, unknown>, ...keys: string[]): string | undefined {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === 'string' && v.trim()) return v.trim();
+  }
+  return undefined;
+}
+
+function pickNum(obj: Record<string, unknown>, ...keys: string[]): number | undefined {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === 'number' && !Number.isNaN(v)) return v;
+    if (typeof v === 'string' && v.trim()) {
+      const n = Number(v);
+      if (!Number.isNaN(n)) return n;
+    }
+  }
+  return undefined;
+}
+
+/** Positive whole days, capped for sanity (DAP cancellation window from TicketBooth). */
+function pickPositiveDayCount(obj: Record<string, unknown>, ...keys: string[]): number | undefined {
+  const n = pickNum(obj, ...keys);
+  if (n === undefined || !Number.isFinite(n)) return undefined;
+  const floor = Math.floor(n);
+  if (floor < 1) return undefined;
+  return Math.min(floor, 365);
+}
+
+function extractDapCancellationDaysBeforeSession(
+  inner: Record<string, unknown> | null | undefined
+): number | undefined {
+  if (!inner) return undefined;
+  const top = pickPositiveDayCount(
+    inner,
+    'cancellationDaysBeforeSession',
+    'cancellation_days_before_session'
+  );
+  if (top !== undefined) return top;
+  const prod =
+    inner.dependentAddOnProduct ?? inner.dependent_add_on_product ?? inner.product;
+  if (prod && typeof prod === 'object') {
+    return pickPositiveDayCount(
+      prod as Record<string, unknown>,
+      'cancellationDaysBeforeSession',
+      'cancellation_days_before_session'
+    );
+  }
+  return undefined;
+}
+
+/** Normalize TicketBooth create-payment-intent JSON (nested `data`, snake_case). */
+function coercePaymentIntentResult(payload: unknown): CreateDependentAddOnPaymentIntentResult {
+  const root = payload && typeof payload === 'object' ? (payload as Record<string, unknown>) : {};
+  const inner =
+    root.data && typeof root.data === 'object'
+      ? (root.data as Record<string, unknown>)
+      : root;
+  return {
+    clientSecret: pickStr(inner, 'clientSecret', 'client_secret'),
+    totalAmount: pickNum(inner, 'totalAmount', 'total_amount'),
+    currency: pickStr(inner, 'currency'),
+    subtotalAmount: pickNum(inner, 'subtotalAmount', 'subtotal_amount'),
+    taxAmount: pickNum(inner, 'taxAmount', 'tax_amount'),
+    customerLastName: pickStr(inner, 'customerLastName', 'customer_last_name'),
+  };
+}
+
+export type DependentAddOnCheckoutQuestionType = 'TEXT' | 'CHECKBOX';
+
+export interface DependentAddOnCheckoutQuestion {
+  id: string;
+  type: DependentAddOnCheckoutQuestionType;
+  label: string;
+  required?: boolean;
+  maxLength?: number | null;
+  placeholder?: string | null;
+  helpText?: string | null;
+}
+
+export interface DependentAddOnSlot {
+  offeringId: string;
+  resourceId: string;
+  resourceName?: string;
+  slotStart: string;
+  slotEnd: string;
+  capacityTotal?: number;
+  capacityRemaining?: number;
+  price?: number;
+  currency?: string;
+  dependentAddOnProductOptionId?: string;
+}
+
+export interface GetDependentAddOnAvailabilityParams {
+  companyId: string;
+  primaryBookingReference: string;
+  lastName: string;
+  dependentAddOnProductId: string;
+  dependentAddOnProductOptionId?: string;
+  /** YYYY-MM-DD — limits slots to one local day when supported */
+  date?: string;
+  /**
+   * When true (default), drop slots not fully inside an arrive→depart on-site window
+   * derived from `primaryItineraryDisplay` in the same response (or after normalize).
+   */
+  filterSlotsByPrimaryItineraryWindows?: boolean;
+  /** Pass from AbortController to cancel in-flight work (e.g. route change, Strict Mode remount). */
+  signal?: AbortSignal;
+}
+
+export type DependentAddOnBookingUpsellProductRow = {
+  dependentAddOnProductId: string;
+  dependentAddOnProductOptionId?: string;
+};
+
+export interface GetDependentAddOnBookingUpsellEligibilityParams {
+  companyId: string;
+  primaryBookingReference: string;
+  lastName: string;
+  signal?: AbortSignal;
+}
+
+/**
+ * Single TicketBooth read for manage-booking photo upsell: ACTIVE DAP products that have at least one
+ * bookable slot for this primary booking (same last-name gate as availability). Replaces N parallel
+ * `getDependentAddOnAvailability` probes.
+ */
+export async function getDependentAddOnBookingUpsellEligibility(
+  params: GetDependentAddOnBookingUpsellEligibilityParams
+): Promise<{ productsWithSlots: DependentAddOnBookingUpsellProductRow[] }> {
+  const endpoint = '/1/dependent-add-ons/booking-upsell-eligibility';
+  const q = new URLSearchParams({
+    companyId: params.companyId,
+    primaryBookingReference: params.primaryBookingReference.trim(),
+    lastName: params.lastName.trim(),
+  });
+  const url = `${API_BASE}${endpoint}?${q}`;
+  if (params.signal?.aborted) {
+    const aborted = new Error('Aborted');
+    aborted.name = 'AbortError';
+    throw aborted;
+  }
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: 'GET',
+      headers: getAuthHeaders(),
+      signal: params.signal,
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === 'AbortError') throw err;
+    if (
+      typeof DOMException !== 'undefined' &&
+      err instanceof DOMException &&
+      err.name === 'AbortError'
+    ) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Unable to load add-on upsell eligibility. ${msg}`);
+  }
+  const payload = await parseJsonSafely(res);
+  if (!res.ok) {
+    throw new Error(
+      messageFromPayload(payload, `Could not load upsell eligibility (HTTP ${res.status})`)
+    );
+  }
+  const data = payload as { data?: Record<string, unknown> } | null;
+  const inner = data?.data;
+  const rawList = inner?.productsWithSlots ?? inner?.products_with_slots;
+  const rows: DependentAddOnBookingUpsellProductRow[] = [];
+  if (Array.isArray(rawList)) {
+    for (const item of rawList) {
+      if (!item || typeof item !== 'object') continue;
+      const o = item as Record<string, unknown>;
+      const id =
+        pickStr(o, 'dependentAddOnProductId', 'dependent_add_on_product_id') ?? '';
+      if (!id) continue;
+      const opt = pickStr(
+        o,
+        'dependentAddOnProductOptionId',
+        'dependent_add_on_product_option_id'
+      );
+      rows.push({
+        dependentAddOnProductId: id,
+        ...(opt ? { dependentAddOnProductOptionId: opt } : {}),
+      });
+    }
+  }
+  return { productsWithSlots: rows };
+}
+
+export type DependentAddOnAvailabilityResult = {
+  slots: DependentAddOnSlot[];
+  /** Present when API includes itinerary for this reference (preview without last name). */
+  primaryItineraryDisplay: DapItineraryStep[];
+  /** Primary booking last name from TicketBooth (for manage-booking after DAP payment). */
+  primaryCustomerLastName?: string;
+  /** When TicketBooth sends it on this DAP product / availability payload. */
+  cancellationDaysBeforeSession?: number;
+  /** Server-defined checkout questionnaire for this DAP (empty if none). */
+  checkoutQuestions: DependentAddOnCheckoutQuestion[];
+};
+
+export async function getDependentAddOnAvailability(
+  params: GetDependentAddOnAvailabilityParams
+): Promise<DependentAddOnAvailabilityResult> {
+  const endpoint = '/1/dependent-add-ons/availability';
+  const q = new URLSearchParams({
+    companyId: params.companyId,
+    primaryBookingReference: params.primaryBookingReference.trim(),
+    lastName: params.lastName.trim(),
+    dependentAddOnProductId: params.dependentAddOnProductId,
+  });
+  if (params.dependentAddOnProductOptionId?.trim()) {
+    q.set('dependentAddOnProductOptionId', params.dependentAddOnProductOptionId.trim());
+  }
+  if (params.date?.trim()) {
+    q.set('date', params.date.trim());
+  }
+  const url = `${API_BASE}${endpoint}?${q}`;
+  if (params.signal?.aborted) {
+    const aborted = new Error('Aborted');
+    aborted.name = 'AbortError';
+    throw aborted;
+  }
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method: 'GET',
+      headers: getAuthHeaders(),
+      signal: params.signal,
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === 'AbortError') throw err;
+    if (
+      typeof DOMException !== 'undefined' &&
+      err instanceof DOMException &&
+      err.name === 'AbortError'
+    ) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Unable to load add-on times. ${msg}`);
+  }
+  const payload = await parseJsonSafely(res);
+  if (!res.ok) {
+    throw new Error(messageFromPayload(payload, `Could not load times (HTTP ${res.status})`));
+  }
+  const data = payload as { data?: Record<string, unknown> } | null;
+  const inner = data?.data;
+  const cancellationDaysBeforeSession = extractDapCancellationDaysBeforeSession(inner);
+  const slots = inner?.slots;
+  const itineraryRaw =
+    inner?.itineraryDisplay ?? inner?.primaryItineraryDisplay ?? null;
+  const primaryCustomerLastName = inner
+    ? pickStr(
+        inner,
+        'primaryCustomerLastName',
+        'primary_customer_last_name'
+      )
+    : undefined;
+  const primaryItineraryDisplay = normalizeDapItinerarySteps(itineraryRaw);
+  const rawSlots = Array.isArray(slots) ? slots : [];
+  const shouldFilterWindows = params.filterSlotsByPrimaryItineraryWindows !== false;
+  const filteredSlots =
+    shouldFilterWindows && primaryItineraryDisplay.length > 0
+      ? filterDapSlotsToPrimaryItineraryWindows(rawSlots, primaryItineraryDisplay)
+      : rawSlots;
+
+  const checkoutQuestions = normalizeCheckoutQuestions(
+    inner?.checkoutQuestions ?? inner?.checkout_questions
+  );
+
+  return {
+    slots: filteredSlots,
+    primaryItineraryDisplay,
+    primaryCustomerLastName,
+    checkoutQuestions,
+    ...(cancellationDaysBeforeSession !== undefined
+      ? { cancellationDaysBeforeSession }
+      : {}),
+  };
+}
+
+function normalizeCheckoutQuestions(raw: unknown): DependentAddOnCheckoutQuestion[] {
+  if (!Array.isArray(raw)) return [];
+  const out: DependentAddOnCheckoutQuestion[] = [];
+  for (const item of raw) {
+    if (!item || typeof item !== 'object') continue;
+    const o = item as Record<string, unknown>;
+    const id = pickStr(o, 'id') ?? '';
+    if (!id) continue;
+    const typeRaw = (pickStr(o, 'type') ?? 'TEXT').toUpperCase();
+    const type: DependentAddOnCheckoutQuestionType =
+      typeRaw === 'CHECKBOX' ? 'CHECKBOX' : 'TEXT';
+    const label = pickStr(o, 'label') ?? id;
+    const required = Boolean(o.required ?? o.Required);
+    const maxLength =
+      typeof o.maxLength === 'number'
+        ? o.maxLength
+        : typeof o.max_length === 'number'
+          ? o.max_length
+          : undefined;
+    const placeholder = pickStr(o, 'placeholder', 'placeholder_text') ?? null;
+    const helpText = pickStr(o, 'helpText', 'help_text') ?? null;
+    out.push({
+      id,
+      type,
+      label,
+      required,
+      maxLength: maxLength ?? null,
+      placeholder,
+      helpText,
+    });
+  }
+  return out;
+}
+
+export interface CreateDependentAddOnPaymentIntentBody {
+  companyId: string;
+  primaryBookingReference: string;
+  lastName: string;
+  dependentAddOnProductId: string;
+  dependentAddOnProductOptionId?: string;
+  offeringId: string;
+  slotStart: string;
+  slotEnd: string;
+  quantity: number;
+  idempotencyKey: string;
+  customerEmail?: string;
+  customerFirstName?: string;
+  customerLastName?: string;
+  /** Keyed by question id; checkboxes use "true" / "false". */
+  checkoutAnswers?: Record<string, string>;
+}
+
+export interface CreateDependentAddOnPaymentIntentResult {
+  clientSecret?: string;
+  totalAmount?: number;
+  currency?: string;
+  /** Pre-tax subtotal (same as TicketBooth pricing config + GST logic) */
+  subtotalAmount?: number;
+  /** GST / tax included in totalAmount for CAD, etc. */
+  taxAmount?: number;
+  /** Primary booking customer last name (for manage-booking redirect). */
+  customerLastName?: string;
+}
+
+/**
+ * Server-priced Stripe PaymentIntent for a dependent add-on. After payment succeeds,
+ * TicketBooth webhook creates the dependent add-on booking (same idempotency key).
+ */
+export async function createDependentAddOnPaymentIntent(
+  body: CreateDependentAddOnPaymentIntentBody
+): Promise<CreateDependentAddOnPaymentIntentResult> {
+  const endpoint = '/checkout/dependent-add-on-payment-intent';
+  let res: Response;
+  try {
+    res = await fetch(`${API_BASE}${endpoint}`, {
+      method: 'POST',
+      headers: getAuthHeaders(),
+      body: JSON.stringify(body),
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Unable to start payment. ${msg}`);
+  }
+  const payload = await parseJsonSafely(res);
+  if (!res.ok) {
+    throw new Error(messageFromPayload(payload, `Could not start payment (HTTP ${res.status})`));
+  }
+  return coercePaymentIntentResult(payload);
+}

package/src/lib/env.ts

@@ -3,10 +3,94 @@
  * Direct access to process.env for Next.js build-time replacement
  * This ensures NEXT_PUBLIC_* variables are properly embedded at build time
  */
+const getApiUrl = (): string => {
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+  
+  if (!apiUrl) {
+    if (process.env.NODE_ENV === 'production') {
+      throw new Error(
+        'NEXT_PUBLIC_API_URL environment variable is required for production builds. ' +
+        'Set it in your .env.local file or build environment.'
+      );
+    }
+    // Development fallback - warn but allow
+    console.warn(
+      '⚠️  NEXT_PUBLIC_API_URL not set. Using localhost fallback. ' +
+      'Set NEXT_PUBLIC_API_URL in .env.local for production API.'
+    );
+    return 'http://localhost:3001';
+  }
+  
+  return apiUrl;
+};
+
+const getGoogleMapsApiKey = (): string => {
+  return process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY ?? '';
+};
+
+const getStripePublishableKey = (): string => {
+  const key = process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY ?? '';
+  return key;
+};
+
+/**
+ * Base64-encoded `user:password` for TicketBooth Basic auth (not including the "Basic " prefix).
+ * Some endpoints (e.g. get-availabilities, reserve) require this; others may work without it.
+ */
+const getBasicAuth = (): string => {
+  return process.env.NEXT_PUBLIC_BASIC_AUTH ?? '';
+};
+
+/** Via Via company ID in TicketBooth (for API calls). */
+const getCompanyId = (): string => {
+  return process.env.NEXT_PUBLIC_COMPANY_ID ?? 'c_LFU0Vx9hS5v3';
+};
+
+/** GA4 Measurement ID (e.g. G-XXXXXXXXXX). Use same as backend for deduplication. */
+const getGa4MeasurementId = (): string => {
+  return process.env.NEXT_PUBLIC_GA4_MEASUREMENT_ID ?? 'G-BVCCYBSHP8';
+};
+
+/** Meta Pixel ID (e.g. 123456789012345). Use same as backend for deduplication. */
+const getMetaPixelId = (): string => {
+  return process.env.NEXT_PUBLIC_META_PIXEL_ID ?? '';
+};
+
+/** App environment: development, staging, or production. Used for analytics, feature flags, etc. */
+export type AppEnv = 'development' | 'staging' | 'production';
+
+const getAppEnv = (): AppEnv => {
+  const raw = process.env.NEXT_PUBLIC_APP_ENV?.toLowerCase();
+  if (raw === 'production' || raw === 'staging') return raw;
+  return 'development';
+};
+
+export const APP_ENV = getAppEnv();
+
+/** True when running in production. Use for GA4, Meta Pixel, etc. */
+export const isProduction = (): boolean => APP_ENV === 'production';
+
+/** True when running in staging. */
+export const isStaging = (): boolean => APP_ENV === 'staging';
+
+/** True when running in development (local or when NEXT_PUBLIC_APP_ENV is unset). */
+export const isDevelopment = (): boolean => APP_ENV === 'development';
+
+/** True when purchase events should only log to console (dev/staging). Phase 2: production sends to GA4/Meta. */
+export const shouldLogPurchaseToConsole = (): boolean =>
+  APP_ENV === 'development' || APP_ENV === 'staging';
+
+/** True when running on localhost (runtime check). Use to avoid sending to GA4/Meta when testing prod build locally. */
+export const isLocalhost = (): boolean =>
+  typeof window !== 'undefined' &&
+  (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1');
+
 export const ENV = {
-  API_URL: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3001',
-  BASIC_AUTH: process.env.NEXT_PUBLIC_BASIC_AUTH || '', // Optional - empty string is valid
-  COMPANY_ID: process.env.NEXT_PUBLIC_COMPANY_ID || 'c_LFU0Vx9hS5v3',
-  GOOGLE_MAPS_API_KEY: process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY || '', // Optional - empty string is valid
-  STRIPE_PUBLISHABLE_KEY: process.env.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY || '', // Required for embedded checkout modal
+  API_URL: getApiUrl(),
+  GOOGLE_MAPS_API_KEY: getGoogleMapsApiKey(),
+  STRIPE_PUBLISHABLE_KEY: getStripePublishableKey(),
+  BASIC_AUTH: getBasicAuth(),
+  COMPANY_ID: getCompanyId(),
+  GA4_MEASUREMENT_ID: getGa4MeasurementId(),
+  META_PIXEL_ID: getMetaPixelId(),
 } as const;

package/src/lib/firebase.ts

@@ -0,0 +1,20 @@
+import { initializeApp } from 'firebase/app';
+import { getFirestore } from 'firebase/firestore';
+
+// Your web app's Firebase configuration
+const firebaseConfig = {
+  apiKey: "AIzaSyDYHq_ytlzlWxByKC8ryisZvSujtviEolY",
+  authDomain: "viavia-website.firebaseapp.com",
+  projectId: "viavia-website",
+  storageBucket: "viavia-website.firebasestorage.app",
+  messagingSenderId: "114849053171",
+  appId: "1:114849053171:web:0f9d0412a13e521284ba86"
+};
+
+// Initialize Firebase
+const app = initializeApp(firebaseConfig);
+
+// Initialize Firestore
+export const db = getFirestore(app);
+
+export default app;

package/src/lib/job-application-api.ts

@@ -0,0 +1,83 @@
+/**
+ * API helpers for job applications (careers page)
+ */
+
+import { ENV } from '@/lib/env';
+
+const API_BASE = ENV.API_URL;
+
+// Via Via company ID (from ticketbooth config)
+export const VIAVIA_COMPANY_ID = 'c_LFU0Vx9hS5v3';
+
+export interface PresignedUploadResult {
+  uploadUrl: string;
+  s3Key: string;
+  contentType: string;
+}
+
+export async function getPresignedUploadUrl(
+  jobId: string,
+  fileType: 'resume' | 'coverLetter',
+  fileName: string
+): Promise<PresignedUploadResult> {
+  const res = await fetch(`${API_BASE}/1/public/job-applications/upload-url`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      jobId,
+      companyId: VIAVIA_COMPANY_ID,
+      fileType: fileType === 'coverLetter' ? 'coverLetter' : 'resume',
+      fileName,
+    }),
+  });
+  if (!res.ok) {
+    const err = await res.json();
+    throw new Error(err.message || err.error || 'Failed to get upload URL');
+  }
+  const data = await res.json();
+  return data.data;
+}
+
+export async function uploadFileToPresignedUrl(
+  url: string,
+  file: File,
+  contentType: string
+): Promise<void> {
+  const res = await fetch(url, {
+    method: 'PUT',
+    headers: { 'Content-Type': contentType },
+    body: file,
+  });
+  if (!res.ok) {
+    throw new Error('Failed to upload file');
+  }
+}
+
+export interface SubmitApplicationPayload {
+  jobId: string;
+  fullName: string;
+  email: string;
+  phone?: string;
+  answers: Record<string, string>;
+  resumeS3Key?: string;
+  coverLetterS3Key?: string;
+}
+
+export async function submitJobApplication(
+  payload: SubmitApplicationPayload
+): Promise<{ applicationId: string }> {
+  const res = await fetch(`${API_BASE}/1/public/job-applications`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      ...payload,
+      companyId: VIAVIA_COMPANY_ID,
+    }),
+  });
+  if (!res.ok) {
+    const err = await res.json();
+    throw new Error(err.message || err.error || 'Failed to submit application');
+  }
+  const data = await res.json();
+  return data.data;
+}

package/src/lib/manage-booking-embed-print.ts

@@ -0,0 +1,16 @@
+/** Partner portal embed → /manage-booking iframe: trigger the iframe's print dialog. */
+export const MANAGE_BOOKING_EMBED_PRINT_MSG = 'viavia:manage-booking-print' as const;
+export const MANAGE_BOOKING_EMBED_PRINT_V = 1 as const;
+
+export type ManageBookingEmbedPrintMessage = {
+  type: typeof MANAGE_BOOKING_EMBED_PRINT_MSG;
+  v: typeof MANAGE_BOOKING_EMBED_PRINT_V;
+};
+
+export function isManageBookingEmbedPrintMessage(
+  data: unknown,
+): data is ManageBookingEmbedPrintMessage {
+  if (typeof data !== 'object' || data === null) return false;
+  const o = data as Record<string, unknown>;
+  return o.type === MANAGE_BOOKING_EMBED_PRINT_MSG && o.v === MANAGE_BOOKING_EMBED_PRINT_V;
+}