@peektravel/app-utilities 0.1.1

package/dist/index.js

@@ -0,0 +1,2924 @@
+import { randomUUID } from 'crypto';
+import * as jwt from 'jsonwebtoken';
+
+// src/internal/gateway-endpoints.ts
+var SALES_ENDPOINT = "sales";
+
+// src/internal/account-users/account-user-converter.ts
+var ACTIVE_STATUS = "ACTIVE";
+function fromAccountUserNode(node) {
+  if (!node || node.status !== ACTIVE_STATUS) {
+    return null;
+  }
+  return {
+    id: node.id,
+    name: node.name,
+    email: node.email,
+    phone: node.phone,
+    assignedActivities: (node.assignedActivities ?? []).map((activity) => ({
+      id: activity.id,
+      name: activity.name
+    }))
+  };
+}
+function fromAccountUserNodes(nodes) {
+  const users = [];
+  for (const node of nodes) {
+    const user = fromAccountUserNode(node);
+    if (user) {
+      users.push(user);
+    }
+  }
+  return users;
+}
+
+// src/internal/account-users/account-user-queries.ts
+var USER_QUERY = `
+  query Sales($first: Int, $after: String) {
+    accountUsers(first: $first, after: $after) {
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+      edges {
+        cursor
+        node {
+          id
+          name
+          email
+          phone
+          status
+          assignedActivities {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+var USER_BY_FILTER_QUERY = `
+  query Sales($first: Int, $filter: AccountUsersFilter) {
+    accountUsers(first: $first, filter: $filter) {
+      edges {
+        cursor
+        node {
+          id
+          name
+          email
+          phone
+          status
+          assignedActivities {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/internal/account-users/account-user-service.ts
+var DEFAULT_PAGE_SIZE = 50;
+var AccountUserService = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+  }
+  client;
+  pageSize;
+  /**
+   * Returns all active account users, walking the cursor pagination to the end.
+   * Inactive users are omitted.
+   */
+  async getAll() {
+    const users = [];
+    let after = null;
+    for (; ; ) {
+      const body = await this.client.request(SALES_ENDPOINT, USER_QUERY, {
+        first: this.pageSize,
+        after
+      });
+      const connection = body.data?.accountUsers;
+      const edges = connection?.edges ?? [];
+      if (edges.length === 0) {
+        break;
+      }
+      users.push(...fromAccountUserNodes(edges.map((edge) => edge.node)));
+      const pageInfo = connection?.pageInfo;
+      if (pageInfo?.hasNextPage && pageInfo.endCursor) {
+        after = pageInfo.endCursor;
+      } else {
+        break;
+      }
+    }
+    return users;
+  }
+  /**
+   * Returns a single active account user by id, or `null` when no active user
+   * matches.
+   */
+  async getById(userId) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      USER_BY_FILTER_QUERY,
+      { first: this.pageSize, filter: { ids: [userId] } }
+    );
+    const firstEdge = (body.data?.accountUsers?.edges ?? [])[0];
+    if (!firstEdge) {
+      return null;
+    }
+    return fromAccountUserNode(firstEdge.node);
+  }
+};
+
+// src/internal/availability/availability-queries.ts
+var AVAILABILITY_TIMES_QUERY = `
+  query Sales($activityId: ID!, $resourceOptionQuantities: [ResourceOptionQuantityData!]!, $date: Date!) {
+    availabilityTimes(activityId: $activityId, resourceOptionQuantities: $resourceOptionQuantities, date: $date) {
+      id
+      time
+      from
+      end
+      duration {
+        name
+        length {
+          amount
+          unit
+        }
+      }
+      status
+      availability {
+        qty
+        taken
+        resourceOptionId
+      }
+    }
+  }
+`;
+
+// src/internal/availability/availability-service.ts
+var AvailabilityService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Returns the availability times for an activity/date and requested quantities. */
+  async getAvailabilityTimes(query) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      AVAILABILITY_TIMES_QUERY,
+      {
+        activityId: query.activityId,
+        resourceOptionQuantities: query.resourceOptionQuantities,
+        date: query.date
+      }
+    );
+    return body.data?.availabilityTimes ?? [];
+  }
+};
+
+// src/models/product.ts
+var ADD_ON_PRODUCT_TYPE = "ADD-ON";
+
+// src/internal/bookings/booking-converter.ts
+var UNKNOWN = "unknown";
+var SOURCE_SOURCE_MAP = {
+  APP_REGISTRY: "app",
+  BOOKING_IMPORTER_FUTURE: "importer",
+  BOOKING_IMPORTER_HISTORIC: "importer",
+  EXPEDIA: "expedia",
+  GROUPON: "groupon",
+  GYG: "getyourguide",
+  HOOK: "internal",
+  INTERNAL_TOOLS: "internal",
+  IOS_PP: "ios",
+  OCTO: "octo",
+  PDC: "peekcom",
+  PEEK_PLUS: "peekcom",
+  PP: "backend",
+  RWG: "rwg",
+  SELF_SERVE: "internal",
+  SYSTEM: "internal",
+  VIATOR: "viator",
+  WIDGET: "website",
+  YELP: "yelp"
+};
+var SOURCE_DESC_MAP = {
+  APP_REGISTRY: "App Store App",
+  BOOKING_IMPORTER_FUTURE: "Booking Importer",
+  BOOKING_IMPORTER_HISTORIC: "Booking Importer",
+  EXPEDIA: "Expedia",
+  GROUPON: "Groupon",
+  GYG: "GetYourGuide",
+  HOOK: "Internal",
+  INTERNAL_TOOLS: "Internal",
+  IOS_PP: "Peek Pro: iOS App",
+  OCTO: "OCTO",
+  PDC: "Peek.com",
+  PEEK_PLUS: "Peek.com",
+  PP: "Peek Pro: Backend",
+  RWG: "Reserve with Google",
+  SELF_SERVE: "Internal",
+  SYSTEM: "Internal",
+  VIATOR: "Viator",
+  WIDGET: "Website Booking Flow",
+  YELP: "Yelp"
+};
+function fromBookingNode(node, includeGuests = false, includePriceBreakdown = false) {
+  const data = node ?? {};
+  const ticketQuantities = data.ticketQuantities ?? [];
+  const app = data.order?.initialQuote?.source?.actor?.app ?? null;
+  const customQuestionAnswers = (data.questionAnswers ?? []).map(
+    (answer) => {
+      const base = {
+        question: answer.questionText,
+        answer: answer.answer
+      };
+      const location = answer.questionLocationSnapshot;
+      if (location && location.latitude && location.longitude) {
+        base.latitude = location.latitude;
+        base.longitude = location.longitude;
+      }
+      return base;
+    }
+  );
+  const customGuestQuestionAnswers = Array.isArray(data.tickets) ? data.tickets.flatMap(
+    (ticket) => Array.isArray(ticket?.questionAnswers) ? ticket.questionAnswers.filter((qa) => qa && qa.answer !== void 0 && qa.questionText !== void 0).map((qa) => ({ question: qa.questionText, answer: qa.answer })) : []
+  ) : [];
+  return {
+    bookingId: data.id || "",
+    displayId: data.displayId || "",
+    source: sourceFromApp(app),
+    sourceApp: app || UNKNOWN,
+    sourceDescription: sourceDescriptionFromApp(app),
+    customerName: data.primaryGuest?.name || "",
+    customerEmail: data.primaryGuest?.email || null,
+    customerPhone: data.primaryGuest?.phone || null,
+    productId: data.activitySnapshot?.id || UNKNOWN,
+    productName: data.activitySnapshot?.name || UNKNOWN,
+    isRentalProduct: data.activitySnapshot?.type === "RENTAL",
+    timeslotId: data.timeSnapshot?.legacyId || null,
+    totalTickets: ticketQuantity(ticketQuantities),
+    ticketDescription: formatTickets(ticketQuantities),
+    tickets: ticketsToTicketArray(ticketQuantities),
+    isCanceled: data.reservationStatus === "CANCELED",
+    isNoShow: data.fulfillmentStatusOverride?.status === "NO_SHOW",
+    isCheckedIn: data.checkinStatus !== "NONE",
+    isReturned: data.returnStatus !== "NONE",
+    purchasedAt: data.purchasedAt || null,
+    purchasedAtUtc: data.purchasedAtUtc || null,
+    startsAt: data.startsAt || null,
+    startsAtUtc: data.startsAtUtc || null,
+    endsAt: data.endsAt || null,
+    endsAtUtc: data.endsAtUtc || null,
+    durationMin: durationInMin(data.startsAt || null, data.endsAt || null),
+    availabilityTimeId: data.availabilityTimeId || null,
+    portalUrl: data.bookingPortalUrl || null,
+    notes: data.operatorNotes || "",
+    valueDisplay: data.value?.total?.formatted || "",
+    valueAmount: data.value?.total?.amount || "",
+    outstandingBalanceAmount: data.balance?.total?.amount || "",
+    outstandingBalanceDisplay: data.balance?.total?.formatted || "",
+    promoCodes: data.order?.promoCodes?.map((promo) => promo.code) ?? [],
+    tips: (data.tips ?? []).map((tip) => ({
+      display: tip.price?.formatted || "",
+      amount: tip.price?.amount || ""
+    })),
+    customQuestionAnswers,
+    customGuestQuestionAnswers,
+    resources: (data.resourcePoolAssignments ?? []).map((resource) => ({
+      quantity: resource.quantity || 0,
+      name: resource.resourcePool?.name || "",
+      shortName: resource.resourcePool?.shortName || ""
+    })),
+    resourcePoolAssignments: mapResourcePoolAssignments(data.resourcePoolAssignments),
+    resellerId: data.order?.channelSnapshot?.id || null,
+    resellerName: resellerNameFromChannelSnapshot(data.order?.channelSnapshot),
+    orderId: data.order?.id || "",
+    convenienceFee: includePriceBreakdown ? mapPrice(data.value?.convenienceFee) : void 0,
+    deposit: includePriceBreakdown ? mapPrice(data.value?.deposit) : void 0,
+    discount: includePriceBreakdown ? mapPrice(data.value?.discount) : void 0,
+    discountedPrice: includePriceBreakdown ? mapPrice(data.value?.discountedPrice) : void 0,
+    fees: includePriceBreakdown ? mapPrice(data.value?.fees) : void 0,
+    flatPartnerFee: includePriceBreakdown ? mapPrice(data.value?.flatPartnerFee) : void 0,
+    price: includePriceBreakdown ? mapPrice(data.value?.price) : void 0,
+    retailPrice: includePriceBreakdown ? mapPrice(data.value?.retailPrice) : void 0,
+    taxes: includePriceBreakdown ? mapPrice(data.value?.taxes) : void 0,
+    tipsBreakdown: includePriceBreakdown ? mapPrice(data.value?.tips) : void 0,
+    guests: includeGuests ? convertGuests(data) : void 0
+  };
+}
+function convertGuests(data) {
+  const bookingGuestsNodes = Array.isArray(data.bookingGuests) ? data.bookingGuests : [];
+  const primaryGuestNode = data.primaryGuest;
+  const primaryId = primaryGuestNode?.id;
+  const guests = [];
+  for (const guestNode of bookingGuestsNodes) {
+    guests.push(mapGuestNode(guestNode, primaryId ? guestNode.id === primaryId : false));
+  }
+  const hasPrimaryInGuests = primaryId ? bookingGuestsNodes.some((guest) => guest.id === primaryId) : false;
+  if (!hasPrimaryInGuests && primaryGuestNode?.id) {
+    guests.push(mapGuestNode(primaryGuestNode, true));
+  }
+  return guests;
+}
+function mapGuestNode(guestNode, isPrimary) {
+  const fieldResponses = Array.isArray(guestNode.fieldResponses) ? guestNode.fieldResponses : [];
+  const metadata = fieldResponses.map((response) => ({
+    id: response.id,
+    name: response.fieldLocation?.field?.name ?? "",
+    value: response.text ?? ""
+  }));
+  return {
+    id: guestNode.id,
+    name: guestNode.name ?? null,
+    country: guestNode.country ?? null,
+    dateOfBirth: guestNode.dateOfBirth ? new Date(guestNode.dateOfBirth) : null,
+    phone: guestNode.phone ?? null,
+    email: guestNode.email ?? null,
+    isGdpr: Boolean(guestNode.isGdpr),
+    isParticipant: Boolean(guestNode.isParticipant),
+    isPrimary,
+    optinSms: Boolean(guestNode.optinSms),
+    optinMarketing: Boolean(guestNode.optinMarketing),
+    postalCode: guestNode.postalCode ?? null,
+    metadata
+  };
+}
+function sourceFromApp(app) {
+  if (!app) return UNKNOWN;
+  return SOURCE_SOURCE_MAP[app] ?? UNKNOWN;
+}
+function sourceDescriptionFromApp(app) {
+  if (!app) return UNKNOWN;
+  return SOURCE_DESC_MAP[app] ?? UNKNOWN;
+}
+function resellerNameFromChannelSnapshot(channelSnapshot) {
+  if (!channelSnapshot) return null;
+  let out = channelSnapshot.name ?? "";
+  if (channelSnapshot.agent?.name) {
+    out += " - " + channelSnapshot.agent.name;
+  }
+  return out;
+}
+function ticketsToTicketArray(ticketQuantities) {
+  if (!ticketQuantities || ticketQuantities.length === 0) return [];
+  return ticketQuantities.map((ticket) => ({
+    name: ticket.resourceOptionSnapshot?.name || "Unknown",
+    quantity: ticket.quantity || 0,
+    ticketId: ticket.resourceOptionSnapshot?.id || "unknown"
+  }));
+}
+function durationInMin(startsAt, endsAt) {
+  if (!startsAt || !endsAt) return 0;
+  const duration = new Date(endsAt).getTime() - new Date(startsAt).getTime();
+  return Math.floor(duration / 1e3 / 60);
+}
+function ticketQuantity(ticketQuantities) {
+  if (!ticketQuantities || ticketQuantities.length === 0) return 0;
+  return ticketQuantities.reduce((acc, ticket) => acc + (ticket.quantity || 0), 0);
+}
+function formatTickets(ticketQuantities) {
+  if (!ticketQuantities || ticketQuantities.length === 0) return "";
+  return ticketQuantities.map((ticket) => `${ticket.quantity || 0}x ${ticket.resourceOptionSnapshot?.name || "Unknown"}`).join(", ");
+}
+function mapResourcePoolAssignments(poolAssignments) {
+  if (!poolAssignments || poolAssignments.length === 0) return [];
+  return poolAssignments.flatMap(
+    (pool) => (pool.resourceAssignments ?? []).map((assignment) => ({
+      id: assignment.resource?.id || "",
+      name: assignment.resource?.name || ""
+    }))
+  );
+}
+function mapPrice(priceData) {
+  if (!priceData || !priceData.amount && !priceData.formatted) {
+    return void 0;
+  }
+  return {
+    amount: priceData.amount || "0",
+    display: priceData.formatted || ""
+  };
+}
+
+// src/internal/bookings/booking-guest-converter.ts
+function fromBookingGuestsResponse(response) {
+  const firstEdge = (response?.sales?.edges ?? [])[0];
+  if (!firstEdge) {
+    return [];
+  }
+  const bookingNode = firstEdge.node;
+  const primaryGuestNode = bookingNode.primaryGuest;
+  const bookingGuestsNodes = Array.isArray(bookingNode.bookingGuests) ? bookingNode.bookingGuests : [];
+  const primaryId = primaryGuestNode?.id;
+  const guests = [];
+  for (const guestNode of bookingGuestsNodes) {
+    guests.push(mapGuestNode(guestNode, primaryId ? guestNode.id === primaryId : false));
+  }
+  const hasPrimaryInGuests = primaryId ? bookingGuestsNodes.some((guest) => guest.id === primaryId) : false;
+  if (!hasPrimaryInGuests && primaryGuestNode) {
+    guests.push(mapGuestNode(primaryGuestNode, true));
+  }
+  return guests;
+}
+
+// src/internal/bookings/payments-on-file-converter.ts
+function fromPaymentsOnFileResponse(response, bookingId) {
+  const firstEdge = (response?.sales?.edges ?? [])[0];
+  if (!firstEdge) {
+    return null;
+  }
+  const order = firstEdge.node.order;
+  const orderId = order?.id ?? "";
+  const rawPaymentSources = order?.paymentSources ?? [];
+  const rawPayments = order?.payments ?? [];
+  const paymentsBySourceId = /* @__PURE__ */ new Map();
+  for (const payment of rawPayments) {
+    const sourceId = payment.paymentSource?.id;
+    if (!sourceId) continue;
+    const mapped = {
+      id: payment.id,
+      paidAt: dateOnly(payment.appliedAt),
+      currentAmount: payment.currentAmount,
+      refundableAmount: payment.refundableAmount
+    };
+    const existing = paymentsBySourceId.get(sourceId);
+    if (existing) {
+      existing.push(mapped);
+    } else {
+      paymentsBySourceId.set(sourceId, [mapped]);
+    }
+  }
+  const paymentsOnFile = rawPaymentSources.map((source) => {
+    const payments = paymentsBySourceId.get(source.id);
+    return {
+      description: source.description,
+      id: source.id,
+      type: source.type,
+      ...payments ? { payments } : {}
+    };
+  });
+  return { bookingId, orderId, paymentsOnFile };
+}
+function dateOnly(iso) {
+  return iso.split("T")[0] ?? iso;
+}
+
+// src/internal/bookings/addon-queries.ts
+var RESERVATION_STATUS_CONFIRMED = "CONFIRMED";
+var ADDON_OPTION_STATUS_CANCELED = "CANCELED";
+var SALES_ADDONS_PAGE_SIZE = 100;
+var SALES_ADDONS_QUERY = `
+  query Sales($after: String, $first: Int, $filter: SalesFilter!, $orderBy: SalesOrdering) {
+    sales(after: $after, first: $first, filter: $filter, orderBy: $orderBy) {
+      pageInfo { endCursor hasNextPage }
+      edges {
+        node {
+          order { id displayId }
+          ... on Booking {
+            displayId
+            id
+            refid
+            reservationStatus
+            items {
+              id
+              refid
+              value { total { amount currency formatted } }
+              reservationStatus
+              options {
+                refid
+                reservationStatus
+                price { amount currency formatted }
+                itemOptionSnapshot { id name }
+                itemSnapshot { id name }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+function buildSalesAddonsVariables(searchString) {
+  return {
+    first: SALES_ADDONS_PAGE_SIZE,
+    after: null,
+    orderBy: { direction: "DESC", field: "STARTS_AT" },
+    filter: { searchString }
+  };
+}
+
+// src/internal/bookings/addon-converter.ts
+var ERROR_INCONSISTENT_ADDON_ITEM_ID = "Add-on group contains options with mismatched item IDs";
+function parseSaleNode(node) {
+  const bookingId = node.id || "";
+  const displayId = node.displayId || "";
+  const orderId = node.order?.id || "";
+  const bookingQuoteRefid = node.refid || "";
+  const bookingQuoteReservationStatus = node.reservationStatus || "";
+  const items = Array.isArray(node.items) ? node.items : [];
+  return items.map((item) => {
+    const options = Array.isArray(item.options) ? item.options : [];
+    const addonItemOptions = options.map((opt) => ({
+      itemId: opt.itemSnapshot?.id || "",
+      optionId: opt.itemOptionSnapshot?.id || "",
+      itemName: opt.itemSnapshot?.name || "",
+      optionName: opt.itemOptionSnapshot?.name || "",
+      optionRefid: opt.refid || "",
+      optionReservationStatus: opt.reservationStatus || "",
+      itemReservationStatus: item.reservationStatus || "",
+      itemRefid: item.refid || ""
+    }));
+    return {
+      bookingId,
+      displayId,
+      orderId,
+      total: item.value?.total ?? null,
+      bookingQuoteRefid,
+      bookingQuoteReservationStatus,
+      addonItemOptions
+    };
+  });
+}
+function toBookingAddon(item) {
+  const options = item.addonItemOptions || [];
+  if (options.length === 0) {
+    return null;
+  }
+  const addonId = options[0].itemId;
+  const addonName = options[0].itemName;
+  if (options.some((opt) => opt.itemId !== addonId)) {
+    throw new Error(ERROR_INCONSISTENT_ADDON_ITEM_ID);
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  options.filter((opt) => opt.optionReservationStatus !== ADDON_OPTION_STATUS_CANCELED).forEach((opt) => {
+    const existing = grouped.get(opt.optionId);
+    if (existing) {
+      existing.quantity += 1;
+    } else {
+      grouped.set(opt.optionId, {
+        addonOptionId: opt.optionId,
+        addonOptionName: opt.optionName,
+        quantity: 1
+      });
+    }
+  });
+  const addonOptions = Array.from(grouped.values());
+  if (addonOptions.length === 0) {
+    return null;
+  }
+  return { addonId, addonName, total: item.total, addonOptions };
+}
+
+// src/internal/bookings/booking-queries.ts
+var SEARCH_BY_PURCHASE_DATE = "purchaseDate";
+var SEARCH_BY_ACTIVITY_DATE = "activityDate";
+function normalizeBookingId(bookingId) {
+  return bookingId.toLowerCase().replace(/-/g, "_");
+}
+var guestFields = `
+  id
+  name
+  country
+  dateOfBirth
+  email
+  isGdpr
+  isParticipant
+  optinSms
+  optinMarketing
+  phone
+  postalCode
+  fieldResponses {
+    id
+    text
+    fieldLocation {
+      field {
+        name
+      }
+    }
+  }
+`;
+var bookingGuestsFields = `
+  bookingGuests {
+    ${guestFields}
+  }
+  primaryGuest {
+    ${guestFields}
+  }
+`;
+var bookingQueryFields = `
+  displayId
+  id
+  primaryGuest {
+    name
+    email
+    phone
+    optinMarketing
+    optinSms
+    isGdpr
+    postalCode
+  }
+  activitySnapshot {
+    type
+    name
+    id
+  }
+  ticketQuantities {
+    quantity
+    resourceOptionSnapshot {
+      name
+      id
+    }
+  }
+  reservationStatus
+  checkinStatus
+  returnStatus
+  fulfillmentStatusOverride {
+    status
+  }
+  timeSnapshot {
+    id
+    legacyId
+  }
+  purchasedAt
+  purchasedAtUtc
+  startsAt
+  startsAtUtc
+  endsAt
+  endsAtUtc
+  availabilityTimeId
+  bookingPortalUrl
+  operatorNotes
+  value {
+    total {
+      formatted
+      amount
+    }
+  }
+  balance {
+    total {
+      amount
+      formatted
+    }
+  }
+  tips {
+    price {
+      amount
+      formatted
+    }
+  }
+  order {
+    displayId
+    id
+    promoCodes {
+      code
+    }
+    channelSnapshot {
+      id
+      name
+      agent {
+        name
+      }
+    }
+    initialQuote {
+      source {
+        actor {
+          app
+        }
+      }
+    }
+  }
+  questionAnswers {
+    answer
+    questionText
+    questionLocationSnapshot {
+      latitude
+      longitude
+    }
+  }
+  tickets {
+    questionAnswers {
+      answer
+      questionText
+    }
+  }
+  resourcePoolAssignments {
+    quantity
+    resourcePool {
+      name
+      shortName
+      resources {
+        name
+      }
+    }
+    resourceAssignments {
+      resource {
+        id
+        name
+      }
+    }
+  }
+`;
+var PRICE_BREAKDOWN_FIELDS = `
+  convenienceFee { amount formatted }
+  deposit { amount formatted }
+  discount { amount formatted }
+  discountedPrice { amount formatted }
+  fees { amount formatted }
+  flatPartnerFee { amount formatted }
+  price { amount formatted }
+  retailPrice { amount formatted }
+  taxes { amount formatted }
+  tips { amount formatted }
+`;
+function buildBookingsListingQuery(includeGuests, includePriceBreakdown) {
+  const guestsSection = includeGuests ? bookingGuestsFields : "";
+  const fields = includePriceBreakdown ? bookingQueryFields.replace("value {", `value { ${PRICE_BREAKDOWN_FIELDS}`) : bookingQueryFields;
+  return `
+    query Sales($after: String, $first: Int, $filter: SalesFilter!, $orderBy: SalesOrdering) {
+      sales(after: $after, first: $first, filter: $filter, orderBy: $orderBy) {
+        pageInfo { endCursor hasNextPage }
+        edges {
+          node {
+            ... on Booking {
+              ${fields}
+              ${guestsSection}
+            }
+          }
+        }
+      }
+    }
+  `;
+}
+var BOOKING_GUESTS_QUERY = `
+  query Sales($after: String, $first: Int, $filter: SalesFilter!, $orderBy: SalesOrdering) {
+    sales(after: $after, first: $first, filter: $filter, orderBy: $orderBy) {
+      pageInfo { endCursor hasNextPage }
+      edges {
+        node {
+          ... on Booking {
+            displayId
+            id
+            ${bookingGuestsFields}
+          }
+        }
+      }
+    }
+  }
+`;
+var BOOKING_PAYMENTS_ON_FILE_QUERY = `
+  query Sales($after: String, $first: Int, $filter: SalesFilter!, $orderBy: SalesOrdering) {
+    sales(after: $after, first: $first, filter: $filter, orderBy: $orderBy) {
+      pageInfo { endCursor hasNextPage }
+      edges {
+        node {
+          order {
+            payments {
+              id
+              paymentSource { id }
+              appliedAt
+              currentAmount { amount currency }
+              refundableAmount { amount currency }
+            }
+            id
+            displayId
+            paymentSources { description type id }
+          }
+          ... on Booking {
+            displayId
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+var UPDATE_OPERATOR_NOTES_MUTATION = `
+  mutation Account($input: UpdateOperatorNotesForBookingInput!) {
+    updateOperatorNotesForBooking(input: $input) {
+      booking { operatorNotes }
+    }
+  }
+`;
+var UPDATE_BOOKING_CHECKIN_MUTATION = `
+  mutation Account($input: UpdateBookingCheckInInput!) {
+    updateBookingCheckIn(input: $input) {
+      booking { checkinStatus }
+    }
+  }
+`;
+var CANCEL_BOOKING_MUTATION = `
+  mutation Account($input: CancelBookingInput!) {
+    cancelBooking(input: $input) {
+      booking { id displayId reservationStatus }
+    }
+  }
+`;
+var APPLY_PAYMENT_TO_ORDER_MUTATION = `
+  mutation ApplyPaymentToOrder($input: ApplyPaymentToOrderInput!) {
+    applyPaymentToOrder(input: $input) {
+      transactionId
+      errors { code detail value }
+    }
+  }
+`;
+var APPLY_REFUND_TO_ORDER_MUTATION = `
+  mutation ApplyRefundToOrder($input: ApplyRefundToOrderInput!) {
+    applyRefundToOrder(input: $input) {
+      transactionId
+      errors { code detail value }
+    }
+  }
+`;
+var CREATE_INVOICE_LINK_MUTATION = `
+  mutation CreateInvoiceLink($input: CreateInvoiceLinkInput!) {
+    createInvoiceLink(input: $input) {
+      invoiceLink { status url }
+      errors { code detail value __typename }
+    }
+  }
+`;
+var CREATE_QUOTE_FROM_ORDER_MUTATION = `
+  mutation CreateQuoteFromOrder($input: CreateQuoteFromOrderInput!) {
+    createQuoteFromOrder(input: $input) {
+      errors { detail value code }
+      quote {
+        id
+        saleQuotes { refid reservationStatus }
+      }
+    }
+  }
+`;
+var UPDATE_QUOTE_V2_MUTATION = `
+  mutation UpdateQuoteV2($input: UpdateQuoteV2Input!) {
+    updateQuoteV2(input: $input) {
+      errors { detail value code }
+      quote { id }
+    }
+  }
+`;
+var AMEND_ORDER_MUTATION = `
+  mutation AmendOrder($input: AmendOrderInput!) {
+    amendOrder(input: $input) {
+      errors { code detail value }
+      order { id }
+    }
+  }
+`;
+var CREATE_QUOTE_V2_MUTATION = `
+  mutation CreateQuoteV2($input: CreateQuoteV2Input!) {
+    createQuoteV2(input: $input) {
+      errors { detail value code }
+      quote { id }
+    }
+  }
+`;
+var CREATE_ORDER_FROM_QUOTE_MUTATION = `
+  mutation CreateOrderFromQuote($input: CreateOrderFromQuoteInput!) {
+    createOrderFromQuote(input: $input) {
+      errors { code detail value }
+      order {
+        id
+        sales {
+          id
+          displayId
+          ... on Booking {
+            balance { total { amount currency formatted } }
+          }
+        }
+      }
+    }
+  }
+`;
+function buildBookingsVariables(params) {
+  const filter = {};
+  const bookingFilter = {};
+  if (params.bookingId) {
+    bookingFilter.ids = [normalizeBookingId(params.bookingId)];
+  } else if (params.timeslotId) {
+    bookingFilter.timeslotRefid = params.timeslotId;
+  } else {
+    if (params.searchBy === SEARCH_BY_ACTIVITY_DATE) {
+      bookingFilter.overlapsRange = `[${params.startDateTime},${params.endDateTime}]`;
+    } else if (params.searchBy === SEARCH_BY_PURCHASE_DATE) {
+      filter.purchasedAtRangeUtc = `[${params.startDateTime},${params.endDateTime}]`;
+    }
+    if (params.productId) {
+      bookingFilter.activityIds = [params.productId];
+    }
+  }
+  if (params.email) {
+    filter.primaryGuestEmail = params.email;
+  }
+  if (params.searchString && params.searchString.length > 0) {
+    filter.searchString = params.searchString;
+  }
+  if (Object.keys(bookingFilter).length > 0) {
+    filter.bookingFilter = bookingFilter;
+  }
+  return {
+    first: params.pageSize,
+    after: params.after,
+    orderBy: { direction: "ASC", field: "STARTS_AT" },
+    filter
+  };
+}
+
+// src/internal/bookings/booking-service.ts
+var DEFAULT_PAGE_SIZE2 = 50;
+var DEFAULT_CANCEL_NOTE = "Canceled";
+var DEFAULT_CUSTOMER_MESSAGE = "Charge initiated via API";
+var BOOKING_ID_PREFIX = "b_";
+var PAYMENT_SOURCE_PREFIX = "ps_";
+var PAYMENT_ID_PREFIX = "pmt_";
+var ALLOWED_PAYMENT_SOURCE_IDS = ["cash/cash", "custom/other", "custom/voucher"];
+var CURRENCY_CODE_REGEX = /^[A-Z]{3}$/;
+var ERROR_ADDON_OPTION_ID_REQUIRED = "addonOptionId is required";
+var ERROR_QUANTITY_INVALID = "quantity must be a positive integer string";
+var ERROR_BOOKING_ID_REQUIRED = "bookingId is required";
+var ERROR_BOOKING_NOT_FOUND = "Booking not found";
+var ERROR_MULTIPLE_BOOKINGS_FOUND = "Expected exactly one booking for the provided bookingId";
+var ERROR_NO_ADDON_OPTION_TO_REMOVE = "No confirmed add-on option matching addonOptionId was found on the booking";
+var ERROR_CREATE_QUOTE_FAILED = "Failed to create quote from order";
+var ERROR_UPDATE_QUOTE_FAILED = "Failed to update quote with add-on";
+var ERROR_AMEND_ORDER_FAILED = "Failed to amend order with add-on";
+var BookingService = class {
+  constructor(client, deps, options = {}) {
+    this.client = client;
+    this.deps = deps;
+    this.pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE2;
+  }
+  client;
+  deps;
+  pageSize;
+  /**
+   * Returns a single booking by id, or null when not found. The `bookingId` is
+   * normalized internally (lowercased, `-` → `_`), so `B-ABC123` and `b_abc123`
+   * resolve to the same booking.
+   *
+   * @example
+   * ```ts
+   * const bookings = peek.getBookingService();
+   * const booking = await bookings.getById("b_abc123", {
+   *   includeGuests: true,
+   *   includePriceBreakdown: true,
+   * });
+   * if (booking) console.log(booking.displayId, booking.outstandingBalanceAmount);
+   * ```
+   */
+  async getById(bookingId, options = {}) {
+    const includeGuests = options.includeGuests ?? false;
+    const includePriceBreakdown = options.includePriceBreakdown ?? false;
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      buildBookingsListingQuery(includeGuests, includePriceBreakdown),
+      buildBookingsVariables({
+        pageSize: this.pageSize,
+        after: null,
+        bookingId: normalizeBookingId(bookingId)
+      })
+    );
+    const firstEdge = (body.data?.sales?.edges ?? [])[0];
+    if (!firstEdge) {
+      return null;
+    }
+    return fromBookingNode(firstEdge.node, includeGuests, includePriceBreakdown);
+  }
+  /** Returns all bookings matching a time range (paginated). */
+  async searchByTimeRange(input) {
+    const includeGuests = input.includeGuests ?? false;
+    const includePriceBreakdown = input.includePriceBreakdown ?? false;
+    return this.fetchPaginated(
+      buildBookingsListingQuery(includeGuests, includePriceBreakdown),
+      {
+        startDateTime: input.start,
+        endDateTime: input.end,
+        searchBy: input.searchBy ?? SEARCH_BY_PURCHASE_DATE,
+        productId: input.productId,
+        email: input.email,
+        searchString: input.searchString
+      },
+      includeGuests,
+      includePriceBreakdown
+    );
+  }
+  /** Returns all bookings on a timeslot (paginated). */
+  async searchByTimeslot(timeslotId, options = {}) {
+    const includeGuests = options.includeGuests ?? false;
+    const includePriceBreakdown = options.includePriceBreakdown ?? false;
+    return this.fetchPaginated(
+      buildBookingsListingQuery(includeGuests, includePriceBreakdown),
+      { timeslotId },
+      includeGuests,
+      includePriceBreakdown
+    );
+  }
+  /** Returns the guests on a booking (primary guest included). */
+  async getGuests(bookingId) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      BOOKING_GUESTS_QUERY,
+      buildBookingsVariables({
+        pageSize: this.pageSize,
+        after: null,
+        bookingId: normalizeBookingId(bookingId)
+      })
+    );
+    return fromBookingGuestsResponse(body.data);
+  }
+  /** Returns the payments on file for a booking, or null when not found. */
+  async getPaymentsOnFile(bookingId) {
+    const normalized = normalizeBookingId(bookingId);
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      BOOKING_PAYMENTS_ON_FILE_QUERY,
+      buildBookingsVariables({ pageSize: this.pageSize, after: null, bookingId: normalized })
+    );
+    return fromPaymentsOnFileResponse(body.data, normalized);
+  }
+  /**
+   * Appends to (or overwrites) a booking's operator notes. Returns the updated
+   * booking, or null when the booking is not found.
+   */
+  async appendNote(bookingId, note, mode = "append") {
+    const normalized = normalizeBookingId(bookingId);
+    const booking = await this.getById(normalized);
+    if (!booking) {
+      return null;
+    }
+    const newNote = mode === "overwrite" || !booking.notes ? note : `${booking.notes}
+${note}`;
+    await this.client.request(SALES_ENDPOINT, UPDATE_OPERATOR_NOTES_MUTATION, {
+      input: { id: normalized, operatorNotes: newNote }
+    });
+    booking.notes = newNote;
+    return booking;
+  }
+  /**
+   * Sets a booking's check-in status. Returns the refreshed booking, or null
+   * when not found.
+   */
+  async setCheckinStatus(bookingId, checkedIn) {
+    const normalized = normalizeBookingId(bookingId);
+    const checkedInAt = checkedIn ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    await this.client.request(SALES_ENDPOINT, UPDATE_BOOKING_CHECKIN_MUTATION, {
+      input: { id: normalized, checkedInAt }
+    });
+    return this.getById(normalized);
+  }
+  /** Cancels a booking and returns its id/displayId/status. */
+  async cancel(bookingId, notes = DEFAULT_CANCEL_NOTE) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      CANCEL_BOOKING_MUTATION,
+      { input: { bookingId: normalizeBookingId(bookingId), notes } }
+    );
+    const booking = body.data?.cancelBooking?.booking;
+    if (!booking) {
+      throw new Error("No booking data returned from cancelBooking");
+    }
+    return {
+      id: booking.id,
+      displayId: booking.displayId,
+      reservationStatus: booking.reservationStatus
+    };
+  }
+  /**
+   * Charges a booking. Validates input, resolves the order + payment source via
+   * payments-on-file, then applies the payment. The `idempotencyKey` is passed
+   * through to Peek.
+   *
+   * @example
+   * ```ts
+   * const result = await peek.getBookingService().makePayment({
+   *   bookingId: "b_abc123",
+   *   paymentSourceId: "custom/other", // or a "ps_…" source on file
+   *   amount: "25.00",
+   *   currency: "USD",
+   *   idempotencyKey: crypto.randomUUID(),
+   * });
+   * console.log(result.transactionId);
+   * ```
+   *
+   * @throws {Error} when `paymentSourceId` is missing or not a `ps_…` id / one
+   * of `cash/cash`, `custom/other`, `custom/voucher`; when `amount` is not a
+   * valid number; when `currency` is not a 3-letter uppercase code; when
+   * `idempotencyKey` is empty; when `bookingId` does not resolve to a `b_…` id;
+   * when the booking or payment source is not found; or when the charge fails.
+   */
+  async makePayment(input) {
+    const normalized = normalizeBookingId(input.bookingId);
+    this.validatePaymentInput(input, normalized);
+    const onFile = await this.getPaymentsOnFile(normalized);
+    if (!onFile) {
+      throw new Error("Booking not found");
+    }
+    if (!onFile.paymentsOnFile.some((source) => source.id === input.paymentSourceId)) {
+      throw new Error("paymentSourceId not found for this booking");
+    }
+    const customerMessage = input.customerMessage ? `${DEFAULT_CUSTOMER_MESSAGE} (${input.customerMessage})` : DEFAULT_CUSTOMER_MESSAGE;
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      APPLY_PAYMENT_TO_ORDER_MUTATION,
+      {
+        input: {
+          amount: { amount: input.amount, currency: input.currency },
+          orderId: onFile.orderId,
+          paymentSourceId: input.paymentSourceId,
+          idempotencyKey: input.idempotencyKey,
+          customerMessage,
+          scopedTo: [normalized]
+        }
+      }
+    );
+    const result = body.data?.applyPaymentToOrder;
+    if (result?.errors && result.errors.length > 0) {
+      throw new Error(`Payment failed: ${result.errors[0].detail}`);
+    }
+    return {
+      transactionId: result?.transactionId ?? "",
+      bookingId: normalized,
+      orderId: onFile.orderId,
+      amount: input.amount,
+      currency: input.currency,
+      paymentSourceId: input.paymentSourceId
+    };
+  }
+  /**
+   * Refunds a booking payment. Validates input, resolves the order + payment via
+   * payments-on-file, then applies the refund.
+   */
+  async refund(input) {
+    const normalized = normalizeBookingId(input.bookingId);
+    this.validateRefundInput(input, normalized);
+    const onFile = await this.getPaymentsOnFile(normalized);
+    if (!onFile) {
+      throw new Error("Booking not found");
+    }
+    const paymentExists = onFile.paymentsOnFile.some(
+      (source) => (source.payments ?? []).some((payment) => payment.id === input.paymentId)
+    );
+    if (!paymentExists) {
+      throw new Error("paymentId not found for this booking");
+    }
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      APPLY_REFUND_TO_ORDER_MUTATION,
+      {
+        input: {
+          amount: { amount: input.amount, currency: input.currency },
+          orderId: onFile.orderId,
+          paymentId: input.paymentId,
+          idempotencyKey: input.idempotencyKey,
+          scopedTo: [normalized]
+        }
+      }
+    );
+    const result = body.data?.applyRefundToOrder;
+    if (result?.errors && result.errors.length > 0) {
+      throw new Error(`Refund failed: ${result.errors[0].detail}`);
+    }
+    return {
+      transactionId: result?.transactionId ?? "",
+      bookingId: normalized,
+      orderId: onFile.orderId,
+      amount: input.amount,
+      currency: input.currency,
+      paymentId: input.paymentId
+    };
+  }
+  /** Creates an invoice link for a booking's order. */
+  async createInvoiceLink(bookingId) {
+    if (!bookingId || bookingId.trim().length === 0) {
+      throw new Error("bookingId is required");
+    }
+    const normalized = normalizeBookingId(bookingId);
+    const booking = await this.getById(normalized);
+    if (!booking || !booking.orderId) {
+      throw new Error("Booking not found");
+    }
+    const orderId = normalizeBookingId(booking.orderId);
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      CREATE_INVOICE_LINK_MUTATION,
+      { input: { orderId } }
+    );
+    const url = body.data?.createInvoiceLink?.invoiceLink?.url;
+    if (!url) {
+      throw new Error("Failed to create invoice link");
+    }
+    return { bookingId: normalized, orderId, invoiceLink: url };
+  }
+  /** Returns the add-ons on a booking, grouped by add-on item (clean model). */
+  async listAddons(bookingId) {
+    const { items, displayId, orderId, normalizedBookingId } = await this.fetchBookingSale(bookingId);
+    const addons = items.map((item) => toBookingAddon(item)).filter((addon) => addon !== null);
+    return {
+      bookingId: items[0]?.bookingId || normalizedBookingId,
+      displayId: items[0]?.displayId || displayId,
+      orderId: items[0]?.orderId || orderId,
+      addons
+    };
+  }
+  /**
+   * Adds an add-on to a booking via createQuoteFromOrder → updateQuoteV2 →
+   * amendOrder. Lists the booking's add-ons first to derive the order id and
+   * reuse an existing add-on refid; resolves the add-on's parent item via the
+   * product service. Returns the booking's add-ons after the change.
+   *
+   * `quantity` is a **positive-integer string** ("1", "2", …); one add-on
+   * itemOption is created per unit. `addonOptionId` is the add-on's item-option
+   * id (a ticket id on an `ADD_ON_PRODUCT_TYPE` product from
+   * {@link ProductService.getAllProducts}).
+   *
+   * @example
+   * ```ts
+   * const result = await peek.getBookingService().addAddon("b_abc123", {
+   *   addonOptionId: "io_helmet",
+   *   quantity: "2",
+   * });
+   * console.log(result.updatedBookingAddons.addons);
+   * ```
+   *
+   * @throws {Error} when `addonOptionId` is missing, `quantity` is not a
+   * positive-integer string, the add-on is not found on any product, or any of
+   * the underlying quote/order mutations fail.
+   */
+  async addAddon(bookingId, input) {
+    const addonOptionId = (input?.addonOptionId || input?.addonId || "").trim();
+    if (!addonOptionId) {
+      throw new Error(ERROR_ADDON_OPTION_ID_REQUIRED);
+    }
+    const quantity = parseQuantity(input?.quantity);
+    if (quantity === null) {
+      throw new Error(ERROR_QUANTITY_INVALID);
+    }
+    const [sale, parentItemId] = await Promise.all([
+      this.fetchBookingSale(bookingId),
+      this.resolveParentItemId(addonOptionId)
+    ]);
+    const normalizedOrderId = normalizeBookingId(sale.orderId);
+    const existingItemRefid = sale.items.filter(
+      (item) => item.bookingQuoteReservationStatus !== ADDON_OPTION_STATUS_CANCELED
+    ).flatMap((item) => item.addonItemOptions).find((opt) => opt.itemId === parentItemId)?.itemRefid;
+    const addonRefid = existingItemRefid || randomUUID();
+    const { quoteId, saleQuoteRefid } = await this.createQuoteFromOrderOrThrow(normalizedOrderId);
+    if (!saleQuoteRefid) {
+      throw new Error(ERROR_CREATE_QUOTE_FAILED);
+    }
+    const itemOptions = Array.from({ length: quantity }, () => ({
+      itemOptionId: addonOptionId,
+      reservationStatus: RESERVATION_STATUS_CONFIRMED,
+      refid: randomUUID()
+    }));
+    await this.updateQuoteOrThrow(quoteId, {
+      bookingQuotes: [
+        {
+          refid: saleQuoteRefid,
+          addons: [
+            {
+              itemOptions,
+              itemId: parentItemId,
+              reservationStatus: RESERVATION_STATUS_CONFIRMED,
+              refid: addonRefid
+            }
+          ],
+          reservationStatus: RESERVATION_STATUS_CONFIRMED
+        }
+      ]
+    });
+    await this.amendOrderOrThrow(quoteId, normalizedOrderId);
+    return { updatedBookingAddons: await this.listAddons(bookingId) };
+  }
+  /**
+   * Removes (cancels) add-on options from a booking. Lists the booking's
+   * add-ons first to get the order id and the existing item/option refids, then
+   * issues the same three mutations as {@link addAddon} but with cancellation
+   * variables. Returns the booking's add-ons after the change.
+   */
+  async removeAddon(bookingId, input) {
+    const addonOptionId = (input?.addonOptionId || input?.addonId || "").trim();
+    if (!addonOptionId) {
+      throw new Error(ERROR_ADDON_OPTION_ID_REQUIRED);
+    }
+    const quantity = parseQuantity(input?.quantity);
+    if (quantity === null) {
+      throw new Error(ERROR_QUANTITY_INVALID);
+    }
+    const sale = await this.fetchBookingSale(bookingId);
+    const normalizedOrderId = normalizeBookingId(sale.orderId);
+    const { bookingQuotes, canceledCount } = buildCancellation(
+      sale.items,
+      addonOptionId,
+      quantity
+    );
+    if (canceledCount === 0) {
+      throw new Error(ERROR_NO_ADDON_OPTION_TO_REMOVE);
+    }
+    const { quoteId } = await this.createQuoteFromOrderOrThrow(normalizedOrderId);
+    await this.updateQuoteOrThrow(quoteId, { bookingQuotes });
+    await this.amendOrderOrThrow(quoteId, normalizedOrderId);
+    return { updatedBookingAddons: await this.listAddons(bookingId) };
+  }
+  /**
+   * Runs the sales add-ons query for a booking, validates that exactly one
+   * booking matched, and parses the node into the internal model.
+   */
+  async fetchBookingSale(bookingId) {
+    const searchString = (bookingId || "").trim();
+    if (!searchString) {
+      throw new Error(ERROR_BOOKING_ID_REQUIRED);
+    }
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      SALES_ADDONS_QUERY,
+      buildSalesAddonsVariables(searchString)
+    );
+    const edges = body.data?.sales?.edges ?? [];
+    if (edges.length === 0) {
+      throw new Error(ERROR_BOOKING_NOT_FOUND);
+    }
+    if (edges.length > 1) {
+      throw new Error(ERROR_MULTIPLE_BOOKINGS_FOUND);
+    }
+    const node = edges[0].node;
+    return {
+      items: parseSaleNode(node),
+      displayId: node.displayId || "",
+      orderId: node.order?.id || "",
+      normalizedBookingId: node.id || ""
+    };
+  }
+  /**
+   * Runs `createQuoteFromOrder` and validates the response, returning the new
+   * quote id and the first sale quote refid (empty string when absent).
+   */
+  async createQuoteFromOrderOrThrow(normalizedOrderId) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      CREATE_QUOTE_FROM_ORDER_MUTATION,
+      { input: { orderId: normalizedOrderId, quoteInput: {} } }
+    );
+    const created = body.data?.createQuoteFromOrder;
+    const quote = created?.quote;
+    if (created?.errors && created.errors.length > 0 || !quote?.id) {
+      throw new Error(ERROR_CREATE_QUOTE_FAILED);
+    }
+    return { quoteId: quote.id, saleQuoteRefid: quote.saleQuotes?.[0]?.refid || "" };
+  }
+  /** Runs `updateQuoteV2` with the given quoteInput and validates the response. */
+  async updateQuoteOrThrow(quoteId, quoteInput) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      UPDATE_QUOTE_V2_MUTATION,
+      { input: { quoteId, quoteInput } }
+    );
+    const updated = body.data?.updateQuoteV2;
+    if (updated?.errors && updated.errors.length > 0 || !updated?.quote) {
+      throw new Error(ERROR_UPDATE_QUOTE_FAILED);
+    }
+  }
+  /** Runs `amendOrder` and validates the response. */
+  async amendOrderOrThrow(quoteId, normalizedOrderId) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      AMEND_ORDER_MUTATION,
+      { input: { quoteId, orderId: normalizedOrderId } }
+    );
+    const amended = body.data?.amendOrder;
+    if (amended?.errors && amended.errors.length > 0 || !amended?.order) {
+      throw new Error(ERROR_AMEND_ORDER_FAILED);
+    }
+  }
+  /**
+   * Creates a booking via createQuoteV2 → createOrderFromQuote, optionally
+   * marking it paid. IDs must be pre-resolved (no free-text matching) — resolve
+   * `activityId` + ticket `resourceOptionId`s from {@link ProductService} and
+   * `availabilityTimeId` from {@link AvailabilityService.getAvailabilityTimes}.
+   *
+   * @example
+   * ```ts
+   * const created = await peek.getBookingService().create({
+   *   activityId: "a_kayak_tour",
+   *   availabilityTimeId: "at_2026_06_20_0900",
+   *   tickets: [{ resourceOptionId: "ro_adult", quantity: 2 }],
+   *   guest: { name: "Sam Rivera", email: "sam@example.com" },
+   *   markAsPaid: true,
+   *   idempotencyKey: crypto.randomUUID(),
+   * });
+   * console.log(created.bookingId, created.displayId, created.balanceFormatted);
+   * ```
+   *
+   * @throws {Error} when `activityId`, `availabilityTimeId`, a ticket
+   * `resourceOptionId`/positive `quantity`, or the guest `name` is missing; when
+   * `markAsPaid` is set without an `idempotencyKey`; or when the quote/order
+   * mutations fail.
+   */
+  async create(input) {
+    validateCreateInput(input);
+    const tickets = input.tickets.flatMap(
+      (ticket) => Array.from({ length: ticket.quantity }, () => ({
+        resourceOptionId: ticket.resourceOptionId,
+        reservationStatus: "CONFIRMED",
+        refid: randomUUID()
+      }))
+    );
+    const bookingQuote = {
+      tickets,
+      activityId: input.activityId,
+      availabilityTimeId: input.availabilityTimeId,
+      refid: randomUUID(),
+      skipCustomerEmail: input.skipCustomerEmail ?? false,
+      guest: {
+        name: input.guest.name,
+        email: input.guest.email ?? null,
+        phone: input.guest.phone ?? null,
+        optinMarketing: input.guest.optinMarketing ?? false,
+        optinSms: input.guest.optinSms ?? false,
+        postalCode: input.guest.postalCode ?? null,
+        country: input.guest.country ?? null
+      }
+    };
+    if (input.operatorNotes) {
+      bookingQuote.operatorNotes = input.operatorNotes;
+    }
+    const quoteInput = { bookingQuotes: [bookingQuote] };
+    if (input.parentOrderId) {
+      quoteInput.source = { clonedFromId: input.parentOrderId };
+    }
+    const quoteBody = await this.client.request(SALES_ENDPOINT, CREATE_QUOTE_V2_MUTATION, {
+      input: { quoteInput }
+    });
+    const quoteResult = quoteBody.data?.createQuoteV2;
+    if (quoteResult?.errors && quoteResult.errors.length > 0 || !quoteResult?.quote?.id) {
+      throw new Error("Failed to create quote");
+    }
+    const quoteId = quoteResult.quote.id;
+    const orderBody = await this.client.request(
+      SALES_ENDPOINT,
+      CREATE_ORDER_FROM_QUOTE_MUTATION,
+      { input: { quoteId } }
+    );
+    const orderResult = orderBody.data?.createOrderFromQuote;
+    if (orderResult?.errors && orderResult.errors.length > 0) {
+      throw new Error("Failed to create order from quote");
+    }
+    const order = orderResult?.order;
+    const sale = order?.sales?.[0];
+    if (!order || !sale) {
+      throw new Error("Order created but no sales found");
+    }
+    const created = {
+      orderId: order.id,
+      bookingId: sale.id,
+      displayId: sale.displayId,
+      balanceAmount: sale.balance?.total?.amount ?? "0.00",
+      balanceCurrency: sale.balance?.total?.currency ?? "USD",
+      balanceFormatted: sale.balance?.total?.formatted ?? "$0.00"
+    };
+    if (input.markAsPaid) {
+      created.transactionId = await this.markCreatedBookingPaid(created, input);
+    }
+    return created;
+  }
+  async markCreatedBookingPaid(booking, input) {
+    const parsedPartial = input.markAsPaidAmount ? parseFloat(input.markAsPaidAmount) : NaN;
+    const amount = !Number.isNaN(parsedPartial) && parsedPartial > 0 ? parsedPartial.toFixed(2) : booking.balanceAmount;
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      APPLY_PAYMENT_TO_ORDER_MUTATION,
+      {
+        input: {
+          amount: { amount, currency: booking.balanceCurrency },
+          orderId: booking.orderId,
+          paymentSourceId: "custom/other",
+          idempotencyKey: input.idempotencyKey,
+          customerMessage: "Marked as paid",
+          scopedTo: [booking.bookingId]
+        }
+      }
+    );
+    const result = body.data?.applyPaymentToOrder;
+    if (result?.errors && result.errors.length > 0 || !result?.transactionId) {
+      throw new Error("Failed to mark booking as paid");
+    }
+    return result.transactionId;
+  }
+  /** Finds the parent item id of an add-on by matching its option id. */
+  async resolveParentItemId(addonOptionId) {
+    const products = await this.deps.productService.getAllProducts();
+    const matched = products.find(
+      (product) => product.type === ADD_ON_PRODUCT_TYPE && product.tickets.some((ticket) => ticket.id === addonOptionId)
+    );
+    if (!matched) {
+      throw new Error("Add-on not found for the provided addonOptionId");
+    }
+    return matched.productId;
+  }
+  validatePaymentInput(input, normalizedBookingId) {
+    if (!input.paymentSourceId || !input.paymentSourceId.startsWith(PAYMENT_SOURCE_PREFIX) && !ALLOWED_PAYMENT_SOURCE_IDS.includes(input.paymentSourceId)) {
+      throw new Error(
+        "paymentSourceId is required and must start with 'ps_' or be one of 'cash/cash', 'custom/other', 'custom/voucher'"
+      );
+    }
+    assertAmount(input.amount);
+    assertCurrency(input.currency);
+    assertIdempotencyKey(input.idempotencyKey);
+    assertBookingId(normalizedBookingId);
+  }
+  validateRefundInput(input, normalizedBookingId) {
+    if (!input.paymentId || !input.paymentId.startsWith(PAYMENT_ID_PREFIX)) {
+      throw new Error("paymentId is required and must start with 'pmt_'");
+    }
+    assertAmount(input.amount);
+    assertCurrency(input.currency);
+    assertIdempotencyKey(input.idempotencyKey);
+    assertBookingId(normalizedBookingId);
+  }
+  async fetchPaginated(query, baseParams, includeGuests, includePriceBreakdown) {
+    const bookings = [];
+    let after = null;
+    for (; ; ) {
+      const body = await this.client.request(
+        SALES_ENDPOINT,
+        query,
+        buildBookingsVariables({ ...baseParams, pageSize: this.pageSize, after })
+      );
+      const sales = body.data?.sales;
+      for (const edge of sales?.edges ?? []) {
+        bookings.push(fromBookingNode(edge.node, includeGuests, includePriceBreakdown));
+      }
+      const pageInfo = sales?.pageInfo;
+      if (pageInfo?.hasNextPage && pageInfo.endCursor) {
+        after = pageInfo.endCursor;
+      } else {
+        break;
+      }
+    }
+    return bookings;
+  }
+};
+function assertAmount(amount) {
+  if (!amount || Number.isNaN(Number(amount))) {
+    throw new Error("amount is required and must be a valid number");
+  }
+}
+function assertCurrency(currency) {
+  if (!currency || !CURRENCY_CODE_REGEX.test(currency)) {
+    throw new Error("currency is required and must be a 3-letter uppercase code");
+  }
+}
+function assertIdempotencyKey(idempotencyKey) {
+  if (!idempotencyKey) {
+    throw new Error("idempotencyKey is required");
+  }
+}
+function assertBookingId(normalizedBookingId) {
+  if (!normalizedBookingId.startsWith(BOOKING_ID_PREFIX)) {
+    throw new Error("bookingId is required and must start with 'b_' or 'B-'");
+  }
+}
+function validateCreateInput(input) {
+  if (!input.activityId) throw new Error("activityId is required");
+  if (!input.availabilityTimeId) throw new Error("availabilityTimeId is required");
+  if (!input.tickets || input.tickets.length === 0) {
+    throw new Error("at least one ticket is required");
+  }
+  if (input.tickets.some((ticket) => !ticket.resourceOptionId || !(ticket.quantity > 0))) {
+    throw new Error("each ticket requires a resourceOptionId and a positive quantity");
+  }
+  if (!input.guest || !input.guest.name) {
+    throw new Error("guest name is required");
+  }
+  if (input.markAsPaid && !input.idempotencyKey) {
+    throw new Error("idempotencyKey is required when markAsPaid is set");
+  }
+}
+function parseQuantity(value) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return null;
+  }
+  const str = String(value).trim();
+  if (!/^\d+$/.test(str)) {
+    return null;
+  }
+  const num = parseInt(str, 10);
+  if (!Number.isFinite(num) || num <= 0) {
+    return null;
+  }
+  return num;
+}
+function buildCancellation(items, addonOptionId, quantity) {
+  let budget = quantity;
+  const byBookingQuote = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (budget <= 0) break;
+    for (const opt of item.addonItemOptions) {
+      if (budget <= 0) break;
+      if (opt.itemReservationStatus !== RESERVATION_STATUS_CONFIRMED || opt.optionReservationStatus !== RESERVATION_STATUS_CONFIRMED || opt.optionId !== addonOptionId) {
+        continue;
+      }
+      let itemMap = byBookingQuote.get(item.bookingQuoteRefid);
+      if (!itemMap) {
+        itemMap = /* @__PURE__ */ new Map();
+        byBookingQuote.set(item.bookingQuoteRefid, itemMap);
+      }
+      let entry = itemMap.get(opt.itemRefid);
+      if (!entry) {
+        entry = { item, canceledOptionRefids: [] };
+        itemMap.set(opt.itemRefid, entry);
+      }
+      entry.canceledOptionRefids.push(opt.optionRefid);
+      budget -= 1;
+    }
+  }
+  const canceledCount = quantity - budget;
+  const bookingQuotes = Array.from(byBookingQuote.entries()).map(
+    ([bookingQuoteRefid, itemMap]) => ({
+      refid: bookingQuoteRefid,
+      addons: Array.from(itemMap.entries()).map(
+        ([itemRefid, { item, canceledOptionRefids }]) => {
+          const canceledSet = new Set(canceledOptionRefids);
+          const itemOptions = canceledOptionRefids.map((refid) => ({
+            reservationStatus: ADDON_OPTION_STATUS_CANCELED,
+            refid
+          }));
+          const allCanceled = item.addonItemOptions.every(
+            (o) => o.optionReservationStatus === ADDON_OPTION_STATUS_CANCELED || canceledSet.has(o.optionRefid)
+          );
+          const addon = { itemOptions, refid: itemRefid };
+          if (allCanceled) {
+            addon.reservationStatus = ADDON_OPTION_STATUS_CANCELED;
+          }
+          return addon;
+        }
+      )
+    })
+  );
+  return { bookingQuotes, canceledCount };
+}
+
+// src/internal/daily-notes/daily-note-converter.ts
+function toDailyNote(response) {
+  const union = response?.dailyNote;
+  if (!union) {
+    return null;
+  }
+  if ("dailyNote" in union) {
+    return cleanNote(union.dailyNote);
+  }
+  return null;
+}
+function fromUpsertResponse(response) {
+  return cleanNote(response?.upsertDailyNote?.dailyNote);
+}
+function cleanNote(note) {
+  if (!note || typeof note.note !== "string") {
+    return null;
+  }
+  return { note: note.note };
+}
+
+// src/internal/daily-notes/daily-note-queries.ts
+var GLOBAL_NOTE_TYPE = "DASHBOARD";
+var DAILY_NOTE_TODAY_QUERY = `
+  query dailyNote($type: GlobalNoteType!) {
+    dailyNote(type: $type) {
+      ... on DailyNoteSuccess {
+        dailyNote {
+          note
+        }
+      }
+      ... on NotFoundError {
+        message
+      }
+    }
+  }
+`;
+var UPSERT_DAILY_NOTE_MUTATION = `
+  mutation Account($input: UpsertDailyNoteInput!) {
+    upsertDailyNote(input: $input) {
+      ... on UpsertDailyNoteSuccess {
+        dailyNote {
+          note
+        }
+      }
+    }
+  }
+`;
+function buildUpsertDailyNoteVariables(note) {
+  return { input: { type: GLOBAL_NOTE_TYPE, note } };
+}
+
+// src/internal/daily-notes/daily-note-service.ts
+var DailyNoteService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Returns today's daily note, or null when none is set. */
+  async getToday() {
+    const body = await this.client.request(SALES_ENDPOINT, DAILY_NOTE_TODAY_QUERY, {
+      type: GLOBAL_NOTE_TYPE
+    });
+    return toDailyNote(body.data);
+  }
+  /** Upserts the daily note and returns the saved note, or null. */
+  async update(note) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      UPSERT_DAILY_NOTE_MUTATION,
+      buildUpsertDailyNoteVariables(note)
+    );
+    return fromUpsertResponse(body.data);
+  }
+};
+
+// src/errors.ts
+var AdminAccountRequiredError = class extends Error {
+  /** The HTTP status that triggered this error. */
+  statusCode = 418;
+  constructor(message = "Admin account required") {
+    super(message);
+    this.name = "AdminAccountRequiredError";
+  }
+};
+var RateLimitError = class extends Error {
+  /** The HTTP status that triggered this error. */
+  statusCode = 429;
+  constructor(message = "Rate limit exceeded") {
+    super(message);
+    this.name = "RateLimitError";
+  }
+};
+var PeekGraphQLError = class extends Error {
+  /** The raw `errors` array returned by the GraphQL endpoint. */
+  graphqlErrors;
+  constructor(graphqlErrors, message = "GraphQL request failed") {
+    super(message);
+    this.name = "PeekGraphQLError";
+    this.graphqlErrors = graphqlErrors;
+  }
+};
+
+// src/internal/graphql-client.ts
+var RATE_LIMIT_STATUS = 429;
+var ADMIN_ACCOUNT_REQUIRED_STATUS = 418;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var GraphQLClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  /**
+   * Executes a GraphQL query against the named endpoint and returns the raw
+   * response body. Retries on HTTP 429 per the configured backoff.
+   */
+  async request(endpointName, query, variables) {
+    const { retryDelaysMs, logger, fetchFn } = this.options;
+    const url = this.endpoint(endpointName);
+    const collapsedQuery = query.replace(/\s+/g, " ").trim();
+    logger.info("Making GraphQL request", { url, endpointName });
+    for (let attempt = 0; attempt <= retryDelaysMs.length; attempt++) {
+      const response = await fetchFn(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ query: collapsedQuery, variables })
+      });
+      if (response.status === ADMIN_ACCOUNT_REQUIRED_STATUS) {
+        logger.warn(`Admin account required for ${endpointName} (HTTP 418)`, { url });
+        throw new AdminAccountRequiredError();
+      }
+      if (response.status === RATE_LIMIT_STATUS) {
+        const delay = retryDelaysMs[attempt];
+        if (delay !== void 0) {
+          logger.warn(
+            `Rate limited on ${endpointName}, retrying in ${delay}ms (attempt ${attempt + 1}/${retryDelaysMs.length})`
+          );
+          await sleep(delay);
+          continue;
+        }
+        logger.error(`Rate limit exceeded for ${endpointName}`, { url });
+        throw new RateLimitError();
+      }
+      const body = await response.json();
+      if (body.errors) {
+        logger.error(`GraphQL errors for ${endpointName}`, {
+          url,
+          graphqlErrors: JSON.stringify(body.errors)
+        });
+        throw new PeekGraphQLError(body.errors);
+      }
+      if (!response.ok) {
+        logger.error(`GraphQL request failed with HTTP ${response.status}`, { url });
+        throw new Error(`GraphQL request failed with HTTP ${response.status}`);
+      }
+      return body;
+    }
+    throw new RateLimitError();
+  }
+  endpoint(endpointName) {
+    return `${this.options.baseUrl}/${this.options.appId}/${endpointName}`;
+  }
+  buildHeaders() {
+    return {
+      "X-Peek-Auth": `Bearer ${this.options.getToken()}`,
+      "pk-api-key": this.options.gatewayKey,
+      "Content-Type": "application/json"
+    };
+  }
+};
+
+// src/internal/memberships/membership-converter.ts
+function fromMembershipsResponse(response) {
+  return (response?.memberships ?? []).flatMap(
+    (membership) => (membership.membershipVariants ?? []).map((variant) => ({
+      id: membership.id,
+      membershipVariantId: variant.id,
+      description: variant.description ?? null,
+      externalName: variant.externalName,
+      imageUrl: variant.imageUrl ?? null,
+      internalName: variant.internalName,
+      displayName: membership.name
+    }))
+  );
+}
+
+// src/internal/memberships/membership-queries.ts
+var MEMBERSHIPS_QUERY = `
+  query Sales {
+    memberships {
+      name
+      id
+      membershipVariants {
+        id
+        description
+        imageUrl
+        externalName
+        internalName
+      }
+    }
+  }
+`;
+var CREATE_QUOTE_V2_MUTATION2 = `
+  mutation CreateQuoteV2($input: CreateQuoteV2Input!) {
+    createQuoteV2(input: $input) {
+      errors { detail value code }
+      quote { id }
+    }
+  }
+`;
+var CREATE_MEMBERSHIP_ORDER_FROM_QUOTE_MUTATION = `
+  mutation CreateOrderFromQuote($input: CreateOrderFromQuoteInput!) {
+    createOrderFromQuote(input: $input) {
+      errors { code detail value }
+      order {
+        id
+        sales {
+          id
+          displayId
+          ... on SoldMembership {
+            id
+            displayId
+            primaryMember { name id }
+            balance { total { amount currency formatted } }
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/internal/memberships/membership-service.ts
+var QUOTE_STATUS_CONFIRMED = "CONFIRMED";
+var DEFAULT_BALANCE_AMOUNT = "0.00";
+var DEFAULT_BALANCE_CURRENCY = "USD";
+var DEFAULT_BALANCE_FORMATTED = "$0.00";
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var COUNTRY_REGEX = /^[A-Z]{2}$/i;
+var PHONE_REGEX = /^[0-9+\s()\-.]+$/;
+var MembershipService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Returns all membership variants, flattened into {@link Membership} records. */
+  async getAll() {
+    const body = await this.client.request(SALES_ENDPOINT, MEMBERSHIPS_QUERY, {});
+    return fromMembershipsResponse(body.data);
+  }
+  /**
+   * Purchases a membership via the two-step quote → order flow. Throws on
+   * invalid input or when Peek returns errors.
+   */
+  async purchase(input) {
+    validatePurchaseInput(input);
+    const quoteBody = await this.client.request(
+      SALES_ENDPOINT,
+      CREATE_QUOTE_V2_MUTATION2,
+      {
+        input: {
+          quoteInput: {
+            membershipQuotes: [
+              {
+                member: buildMember(input),
+                membershipVariantId: input.membershipVariantId,
+                refid: randomUUID(),
+                status: QUOTE_STATUS_CONFIRMED
+              }
+            ]
+          }
+        }
+      }
+    );
+    const quoteResult = quoteBody.data?.createQuoteV2;
+    if (quoteResult?.errors && quoteResult.errors.length > 0) {
+      throw new Error(`Failed to create membership quote: ${quoteResult.errors[0].detail}`);
+    }
+    const quoteId = quoteResult?.quote?.id;
+    if (!quoteId) {
+      throw new Error("Membership quote created but missing quote id");
+    }
+    const orderBody = await this.client.request(
+      SALES_ENDPOINT,
+      CREATE_MEMBERSHIP_ORDER_FROM_QUOTE_MUTATION,
+      { input: { quoteId } }
+    );
+    const orderResult = orderBody.data?.createOrderFromQuote;
+    if (orderResult?.errors && orderResult.errors.length > 0) {
+      throw new Error(`Failed to create membership order: ${orderResult.errors[0].detail}`);
+    }
+    const order = orderResult?.order;
+    const sale = order?.sales?.[0];
+    if (!order || !sale) {
+      throw new Error("Membership order created but no sales found");
+    }
+    return {
+      orderId: order.id,
+      membershipId: sale.id,
+      displayId: sale.displayId,
+      primaryMemberId: sale.primaryMember?.id ?? null,
+      primaryMemberName: sale.primaryMember?.name ?? null,
+      balanceAmount: sale.balance?.total?.amount ?? DEFAULT_BALANCE_AMOUNT,
+      balanceCurrency: sale.balance?.total?.currency ?? DEFAULT_BALANCE_CURRENCY,
+      balanceFormatted: sale.balance?.total?.formatted ?? DEFAULT_BALANCE_FORMATTED
+    };
+  }
+};
+function buildMember(input) {
+  const member = { email: input.email };
+  if (input.country?.trim()) member.country = input.country;
+  if (input.formattedAddress?.trim()) member.formattedAddress = input.formattedAddress;
+  if (input.membershipCode?.trim()) member.membershipCode = input.membershipCode;
+  if (input.name?.trim()) member.name = input.name;
+  if (input.phone?.trim()) member.phone = input.phone;
+  return member;
+}
+function validatePurchaseInput(input) {
+  const errors = [];
+  if (!input.membershipVariantId || input.membershipVariantId.trim().length === 0) {
+    errors.push("membershipVariantId is required");
+  }
+  if (!input.email || input.email.trim().length === 0) {
+    errors.push("email is required");
+  } else if (!EMAIL_REGEX.test(input.email)) {
+    errors.push("email is invalid");
+  }
+  if (input.country && !COUNTRY_REGEX.test(input.country)) {
+    errors.push("country is invalid");
+  }
+  if (input.phone && !PHONE_REGEX.test(input.phone)) {
+    errors.push("phone is invalid");
+  }
+  if (errors.length > 0) {
+    throw new Error(errors.join(", "));
+  }
+}
+
+// src/internal/resellers/channel-converter.ts
+function fromChannelsResponse(response) {
+  return (response?.channels ?? []).map(fromChannelNode);
+}
+function fromChannelNode(node) {
+  return {
+    id: node.id,
+    name: node.name,
+    notes: node.notes,
+    pricingModel: node.pricingModel,
+    state: node.state,
+    type: node.type,
+    agents: (node.agents?.edges ?? []).map((edge) => ({
+      email: edge.node.email,
+      name: edge.node.name,
+      internalNotes: edge.node.internalNotes,
+      phone: edge.node.phone
+    }))
+  };
+}
+
+// src/internal/resellers/channel-queries.ts
+var CHANNELS_QUERY = `
+  query Sales($first: Int) {
+    channels {
+      id
+      agents(first: $first) {
+        edges {
+          node {
+            email
+            name
+            internalNotes
+            phone
+          }
+        }
+      }
+      name
+      notes
+      state
+      type
+      pricingModel
+    }
+  }
+`;
+
+// src/internal/resellers/reseller-service.ts
+var DEFAULT_AGENTS_PER_CHANNEL = 10;
+var ResellerService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Returns all reseller channels, each with up to `agentsPerChannel` agents
+   * (default 10).
+   */
+  async getAllChannels(agentsPerChannel = DEFAULT_AGENTS_PER_CHANNEL) {
+    const body = await this.client.request(SALES_ENDPOINT, CHANNELS_QUERY, {
+      first: agentsPerChannel
+    });
+    return fromChannelsResponse(body.data);
+  }
+};
+
+// src/internal/resource-pools/resource-pool-converter.ts
+function fromResourcePoolsResponse(response) {
+  return (response?.resourcePools ?? []).map(fromResourcePoolNode);
+}
+function fromResourcePoolNode(pool) {
+  return {
+    id: pool.id || "",
+    name: pool.name || "",
+    imageUrl: pool.imageUrl ?? null,
+    mode: pool.mode || "",
+    colorHex: pool.colorHex ?? null,
+    quantity: pool.quantity ?? null,
+    category: pool.category || "",
+    capacity: pool.capacity ?? null,
+    resourceTrackingMode: pool.resourceTrackingMode ?? null,
+    accountUser: fromAccountUser(pool.accountUser)
+  };
+}
+function fromAccountUser(accountUser) {
+  if (!accountUser) {
+    return null;
+  }
+  return {
+    id: accountUser.id || "",
+    name: accountUser.name || ""
+  };
+}
+
+// src/internal/resource-pools/resource-pool-queries.ts
+var RESOURCE_POOLS_QUERY = `
+  query Sales($filter: ResourcePoolsFilter) {
+    resourcePools(filter: $filter) {
+      id
+      name
+      imageUrl
+      mode
+      colorHex
+      quantity
+      category
+      capacity
+      resourceTrackingMode
+      accountUser {
+        id
+        name
+      }
+    }
+  }
+`;
+
+// src/internal/resource-pools/resource-pool-service.ts
+var DEFAULT_MODE = "ALL";
+var ResourcePoolService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * Returns all resource pools for the given mode filter (defaults to `"ALL"`).
+   */
+  async getAll(mode = DEFAULT_MODE) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      RESOURCE_POOLS_QUERY,
+      { filter: { mode } }
+    );
+    return fromResourcePoolsResponse(body.data);
+  }
+};
+
+// src/internal/timeslots/timeslot-converter.ts
+function fromTimeslotNodes(nodes, productId) {
+  if (!Array.isArray(nodes) || nodes.length === 0) {
+    return [];
+  }
+  return nodes.map((node) => fromTimeslotNode(node, productId));
+}
+function fromTimeslotNode(node, productId) {
+  if (!node) {
+    return {
+      id: "",
+      productId,
+      totalCapacity: 0,
+      availableCapacity: 0,
+      maxPartySize: 0,
+      bookingCount: 0,
+      checkedInCount: 0,
+      status: "",
+      notes: null,
+      durationMin: 0,
+      date: "",
+      startTime: null,
+      assignedResources: []
+    };
+  }
+  return {
+    id: node.id || "",
+    productId,
+    totalCapacity: node.totalCapacity ?? 0,
+    availableCapacity: node.availableSpots ?? 0,
+    maxPartySize: node.maxPartySize ?? 0,
+    bookingCount: node.bookingCount ?? 0,
+    checkedInCount: node.checkedInCount ?? 0,
+    status: node.status || "",
+    notes: node.manifestNotes ?? null,
+    durationMin: node.minuteLength ?? 0,
+    date: node.date || "",
+    startTime: node.start ?? null,
+    assignedResources: mapAssignedResources(node.resourceAllocations)
+  };
+}
+function mapAssignedResources(allocations) {
+  if (!Array.isArray(allocations) || allocations.length === 0) {
+    return [];
+  }
+  return allocations.map((allocation) => {
+    const pool = allocation.resourcePool;
+    return {
+      id: pool?.id || "",
+      name: pool?.name || "",
+      capacity: pool?.capacity ?? 0,
+      category: pool?.category || "",
+      quantity: allocation.quantity ?? 0,
+      accountUserId: pool?.accountUser?.id ?? null
+    };
+  });
+}
+
+// src/internal/timeslots/guide-matcher.ts
+function matchGuideToResourcePool(guideId, guideResourcePools, accountUsers) {
+  const directIdMatch = guideResourcePools.find((pool) => pool.id === guideId);
+  if (directIdMatch) {
+    return directIdMatch.id;
+  }
+  const accountUserMatch = guideResourcePools.find(
+    (pool) => pool.accountUser?.id === guideId
+  );
+  if (accountUserMatch) {
+    return accountUserMatch.id;
+  }
+  const nameMatch = guideResourcePools.find((pool) => pool.name === guideId);
+  if (nameMatch) {
+    return nameMatch.id;
+  }
+  const matchedUser = accountUsers.find((user) => user.id === guideId);
+  if (matchedUser) {
+    const userIdMatch = guideResourcePools.find(
+      (pool) => pool.accountUser?.id === matchedUser.id
+    );
+    if (userIdMatch) {
+      return userIdMatch.id;
+    }
+    const userNameMatch = guideResourcePools.find(
+      (pool) => pool.name === matchedUser.name
+    );
+    if (userNameMatch) {
+      return userNameMatch.id;
+    }
+  }
+  return null;
+}
+
+// src/internal/timeslots/resource-allocation-queries.ts
+var RESOURCE_ALLOCATION_BULK_REQUEST_MUTATION = `
+  mutation ResourceAllocationBulkRequest($input: ResourceAllocationBulkRequestInput!) {
+    resourceAllocationBulkRequest(input: $input) {
+      __typename
+      ... on ResourceAllocationRequest {
+        id
+      }
+      ... on GenericError {
+        __typename
+        message
+      }
+    }
+  }
+`;
+function buildResourceAllocationVariables(timeslotIds, resourcePoolIds, status) {
+  return { input: { timeslotIds, resourcePoolIds, status } };
+}
+
+// src/internal/timeslots/timeslot-queries.ts
+var TIMESLOTS_QUERY = `
+  query Sales($params: TimeslotsFilter!) {
+    timeslots(filter: $params) {
+      ... on TimeslotsSuccess {
+        timeslots {
+          id
+          bookingCount
+          availableSpots
+          maxPartySize
+          totalCapacity
+          checkedInCount
+          manifestNotes
+          minuteLength
+          status
+          date
+          resourceAllocations {
+            quantity
+            resourcePool {
+              id
+              name
+              category
+              capacity
+              accountUser {
+                id
+              }
+            }
+          }
+          ... on VariableTimeslot {
+            start
+          }
+          ... on FixedTimeslot {
+            start
+          }
+        }
+      }
+    }
+  }
+`;
+var TIMESLOT_BY_ID_QUERY = `
+  query Sales($id: ID!) {
+    timeslot(id: $id) {
+      ... on ActivityTimeslotSuccess {
+        timeslot {
+          id
+          bookingCount
+          availableSpots
+          maxPartySize
+          totalCapacity
+          checkedInCount
+          manifestNotes
+          minuteLength
+          status
+          date
+          resourceAllocations {
+            quantity
+            resourcePool {
+              id
+              name
+              category
+              capacity
+              accountUser {
+                id
+              }
+            }
+          }
+          ... on VariableTimeslot {
+            start
+          }
+          ... on FixedTimeslot {
+            start
+          }
+        }
+      }
+    }
+  }
+`;
+var UPDATE_TIMESLOT_MUTATION = `
+  mutation Account($input: UpdateTimeslotInput!) {
+    updateTimeslot(input: $input) {
+      ... on UpdateTimeslotSuccess {
+        timeslot {
+          id
+          manifestNotes
+          status
+        }
+      }
+    }
+  }
+`;
+function buildTimeslotVariables(productId, date, filter) {
+  const params = {
+    activityIds: [productId],
+    dateRange: `[${date},${date}]`
+  };
+  if (filter === "withBookings") {
+    params.hasBookings = true;
+  } else if (filter === "withoutBookings") {
+    params.hasBookings = false;
+  }
+  return { params };
+}
+
+// src/internal/timeslots/timeslot-service.ts
+var GUIDE_CATEGORY = "guide";
+var ERROR_MISSING_TIMESLOTS_OR_GUIDES = "At least one timeslot and one guide are required";
+var ERROR_INVALID_ACTION = "Invalid action. Must be either assign or unassign";
+var ERROR_GUIDE_NOT_FOUND = "Guide not found";
+var TimeslotService = class {
+  constructor(client, deps) {
+    this.client = client;
+    this.deps = deps;
+  }
+  client;
+  deps;
+  /** Returns the timeslots for an activity on a given date. */
+  async getForDay(productId, date, filter = "all") {
+    const normalizedDate = normalizeDate(date);
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      TIMESLOTS_QUERY,
+      buildTimeslotVariables(productId, normalizedDate, filter)
+    );
+    return fromTimeslotNodes(body.data?.timeslots?.timeslots ?? [], productId);
+  }
+  /** Returns a single timeslot by id, or null when not found. */
+  async getById(timeslotId) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      TIMESLOT_BY_ID_QUERY,
+      { id: timeslotId }
+    );
+    const node = body.data?.timeslot?.timeslot;
+    if (!node) {
+      return null;
+    }
+    return fromTimeslotNode(node, extractProductId(timeslotId));
+  }
+  /** Sets the timeslot's status (e.g. open/closed). */
+  async setAvailability(timeslotId, status) {
+    return this.updateTimeslot({ id: timeslotId, status });
+  }
+  /** Sets the timeslot's manifest notes. */
+  async setNotes(timeslotId, manifestNotes) {
+    return this.updateTimeslot({ id: timeslotId, manifestNotes });
+  }
+  /**
+   * Assigns or unassigns guides across timeslots. Guides are resolved to
+   * resource pools (by pool id, account-user id, or name) before the bulk
+   * allocation request is issued.
+   *
+   * @example
+   * ```ts
+   * await peek.getTimeslotService().assignGuide({
+   *   timeslotIds: ["ts_2026_06_20_0900"],
+   *   guideIds: ["Alex Guide"], // pool id, account-user id, or name
+   *   action: "assign",
+   * });
+   * ```
+   */
+  async assignGuide(assignment) {
+    const { timeslotIds, guideIds, action } = assignment;
+    if (!timeslotIds?.length || !guideIds?.length) {
+      throw new Error(ERROR_MISSING_TIMESLOTS_OR_GUIDES);
+    }
+    if (action !== "assign" && action !== "unassign") {
+      throw new Error(ERROR_INVALID_ACTION);
+    }
+    const [allPools, accountUsers] = await Promise.all([
+      this.deps.resourcePoolService.getAll(),
+      this.deps.accountUserService.getAll()
+    ]);
+    const guidePools = allPools.filter((pool) => pool.category === GUIDE_CATEGORY);
+    const resourcePoolIds = guideIds.map((guideId) => {
+      const matched = matchGuideToResourcePool(guideId, guidePools, accountUsers);
+      if (!matched) {
+        throw new Error(`${ERROR_GUIDE_NOT_FOUND}: ${guideId}`);
+      }
+      return matched;
+    });
+    const status = action === "assign" ? "ACTIVE" : "REMOVAL";
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      RESOURCE_ALLOCATION_BULK_REQUEST_MUTATION,
+      buildResourceAllocationVariables(timeslotIds, resourcePoolIds, status)
+    );
+    const result = body.data?.resourceAllocationBulkRequest;
+    if (result?.__typename === "ResourceAllocationRequest") {
+      return {
+        status: "success",
+        resourceAllocationRequestId: result.id,
+        errors: null
+      };
+    }
+    return {
+      status: "error",
+      resourceAllocationRequestId: null,
+      errors: [{ message: result?.message ?? "Unknown error" }]
+    };
+  }
+  async updateTimeslot(input) {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      UPDATE_TIMESLOT_MUTATION,
+      { input }
+    );
+    const timeslot = body.data?.updateTimeslot?.timeslot;
+    return {
+      manifestNotes: timeslot?.manifestNotes ?? null,
+      status: timeslot?.status ?? null
+    };
+  }
+};
+function extractProductId(timeslotId) {
+  return timeslotId.split("|")[0] ?? "";
+}
+function normalizeDate(date) {
+  return date.split("T")[0] ?? date;
+}
+
+// src/internal/products/product-converter.ts
+var ADD_ON_COLOR = "#FFFFFF";
+function fromActivities(activities) {
+  return activities.map(fromActivity);
+}
+function fromActivity(activity) {
+  return {
+    // Prefer the primary GraphQL ID for stable product identity.
+    productId: activity.id || activity.legacyId || "",
+    name: activity.name,
+    type: activity.type,
+    color: activity.colorHex || "",
+    tickets: (activity.resourceOptions ?? []).map((option) => ({
+      id: option.id,
+      name: option.name
+    }))
+  };
+}
+function fromItemOptionNodes(nodes) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const itemId = node.item?.id;
+    if (!itemId) continue;
+    let product = grouped.get(itemId);
+    if (!product) {
+      product = {
+        productId: itemId,
+        name: node.item.name,
+        type: ADD_ON_PRODUCT_TYPE,
+        color: ADD_ON_COLOR,
+        tickets: []
+      };
+      grouped.set(itemId, product);
+    }
+    product.tickets.push({ id: node.id, name: node.name });
+  }
+  return Array.from(grouped.values());
+}
+
+// src/internal/products/product-queries.ts
+var PRODUCTS_QUERY = `
+  query Sales {
+    activities {
+      name
+      legacyId
+      id
+      deletedAt
+      type
+      colorHex
+      resourceOptions {
+        id
+        name
+      }
+    }
+  }
+`;
+var ITEM_OPTIONS_QUERY = `
+  query GetItemOptions($first: Int, $after: String) {
+    itemOptions(first: $first, after: $after) {
+      edges {
+        cursor
+        node {
+          id
+          name
+          description
+          item {
+            id
+            name
+          }
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+
+// src/internal/products/product-service.ts
+var DEFAULT_ITEM_OPTIONS_PAGE_SIZE = 50;
+var ProductService = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.itemOptionsPageSize = options.itemOptionsPageSize ?? DEFAULT_ITEM_OPTIONS_PAGE_SIZE;
+  }
+  client;
+  itemOptionsPageSize;
+  /**
+   * Returns every product as a single flat list: activities plus add-ons (the
+   * latter tagged with the add-on type). Add-ons are gathered across all
+   * cursor-paginated pages.
+   *
+   * @example Split activities from add-ons
+   * ```ts
+   * import { ADD_ON_PRODUCT_TYPE } from "@peektravel/app-utilities";
+   *
+   * const products = await peek.getProductService().getAllProducts();
+   * const activities = products.filter((p) => p.type !== ADD_ON_PRODUCT_TYPE);
+   * const addons = products.filter((p) => p.type === ADD_ON_PRODUCT_TYPE);
+   * ```
+   */
+  async getAllProducts() {
+    const [activities, itemOptionNodes] = await Promise.all([
+      this.fetchActivities(),
+      this.fetchAllItemOptionNodes()
+    ]);
+    return [...fromActivities(activities), ...fromItemOptionNodes(itemOptionNodes)];
+  }
+  async fetchActivities() {
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      PRODUCTS_QUERY,
+      {}
+    );
+    return body.data?.activities ?? [];
+  }
+  async fetchAllItemOptionNodes() {
+    const all = [];
+    let after = null;
+    for (; ; ) {
+      const body = await this.client.request(
+        SALES_ENDPOINT,
+        ITEM_OPTIONS_QUERY,
+        { first: this.itemOptionsPageSize, after }
+      );
+      const connection = body.data?.itemOptions;
+      for (const edge of connection?.edges ?? []) {
+        all.push(edge.node);
+      }
+      const pageInfo = connection?.pageInfo;
+      if (pageInfo?.hasNextPage && pageInfo.endCursor) {
+        after = pageInfo.endCursor;
+      } else {
+        break;
+      }
+    }
+    return all;
+  }
+};
+
+// src/internal/promo-codes/promo-code-queries.ts
+var PROMO_CODES_QUERY = `
+  query Sales($first: Int, $after: String) {
+    promoCodes(first: $first, after: $after) {
+      edges {
+        node {
+          id
+          name
+          percentAmount
+          perTicketDiscount
+          redemptionCode
+          fixedAmount {
+            amount
+            currency
+            formatted
+          }
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var CREATE_PROMO_CODE_MUTATION = `
+  mutation Sales($input: CreatePromoCodeInput!) {
+    createPromoCode(input: $input) {
+      ... on InvalidDataError {
+        message
+      }
+      ... on PromoCode {
+        id
+        name
+      }
+    }
+  }
+`;
+
+// src/internal/promo-codes/promo-code-service.ts
+var DEFAULT_PAGE_SIZE3 = 50;
+var DEFAULT_CURRENCY = "USD";
+var CURRENCY_PATTERN = /^[A-Z]{3}$/;
+var PromoCodeService = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE3;
+  }
+  client;
+  pageSize;
+  /** Returns all promo codes, walking the cursor pagination to the end. */
+  async getAll() {
+    const all = [];
+    let after = null;
+    for (; ; ) {
+      const body = await this.client.request(SALES_ENDPOINT, PROMO_CODES_QUERY, {
+        first: this.pageSize,
+        after
+      });
+      const connection = body.data?.promoCodes;
+      for (const edge of connection?.edges ?? []) {
+        all.push(edge.node);
+      }
+      const pageInfo = connection?.pageInfo;
+      if (pageInfo?.hasNextPage && pageInfo.endCursor) {
+        after = pageInfo.endCursor;
+      } else {
+        break;
+      }
+    }
+    return all;
+  }
+  /**
+   * Creates a promo code. Throws on invalid input or when Peek returns an
+   * InvalidDataError.
+   */
+  async create(input) {
+    if (!input.name) throw new Error("name is required");
+    if (!input.code) throw new Error("code is required");
+    if (!input.amount) throw new Error("amount is required");
+    if (!input.discountType) throw new Error("discountType is required");
+    if (input.discountType !== "percent" && input.discountType !== "fixed") {
+      throw new Error("discountType must be either 'percent' or 'fixed'");
+    }
+    if (Number.isNaN(parseFloat(input.amount))) {
+      throw new Error("amount must be a valid number");
+    }
+    const currency = input.currency || DEFAULT_CURRENCY;
+    if (!CURRENCY_PATTERN.test(currency)) {
+      throw new Error("currency must be 3 uppercase letters");
+    }
+    const variables = {
+      input: {
+        code: input.code,
+        name: input.name,
+        maxRedeemCount: input.maxRedemptions ? parseInt(String(input.maxRedemptions), 10) : void 0
+      }
+    };
+    if (input.discountType === "fixed") {
+      variables.input.fixedAmount = { amount: input.amount, currency };
+    } else {
+      variables.input.percentAmount = input.amount;
+    }
+    const body = await this.client.request(
+      SALES_ENDPOINT,
+      CREATE_PROMO_CODE_MUTATION,
+      variables
+    );
+    const result = body.data?.createPromoCode;
+    if (result && "message" in result) {
+      throw new Error(result.message);
+    }
+    if (!result) {
+      throw new Error("createPromoCode returned no data");
+    }
+    return { id: result.id, name: result.name };
+  }
+};
+var TokenManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  cached;
+  /**
+   * Returns a valid bearer token, reusing the cached one until it is within
+   * `leewaySeconds` of expiring, at which point a fresh token is minted.
+   */
+  getToken() {
+    const now = Date.now();
+    if (this.cached && now < this.cached.expiresAtMs) {
+      return this.cached.token;
+    }
+    const { secret, issuer, installId, ttlSeconds, leewaySeconds } = this.options;
+    const token = jwt.sign({}, secret, {
+      expiresIn: ttlSeconds,
+      issuer,
+      subject: installId
+    });
+    this.cached = {
+      token,
+      expiresAtMs: now + (ttlSeconds - leewaySeconds) * 1e3
+    };
+    return token;
+  }
+};
+
+// src/logger.ts
+var noopLogger = {
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+
+// src/peek-access-service.ts
+var DEFAULT_BASE_URL = "https://apps.peekapis.com/backoffice-gql";
+var DEFAULT_TOKEN_TTL_SECONDS = 3600;
+var DEFAULT_TOKEN_REFRESH_LEEWAY_SECONDS = 60;
+var DEFAULT_RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
+var PeekAccessService = class {
+  client;
+  productServiceOptions;
+  productService;
+  accountUserService;
+  resourcePoolService;
+  timeslotService;
+  resellerService;
+  promoCodeService;
+  dailyNoteService;
+  availabilityService;
+  membershipService;
+  bookingService;
+  constructor(config) {
+    requireNonEmpty(config.installId, "installId");
+    requireNonEmpty(config.jwtSecret, "jwtSecret");
+    requireNonEmpty(config.issuer, "issuer");
+    requireNonEmpty(config.appId, "appId");
+    requireNonEmpty(config.gatewayKey, "gatewayKey");
+    const logger = config.logger ?? noopLogger;
+    const tokens = new TokenManager({
+      secret: config.jwtSecret,
+      issuer: config.issuer,
+      installId: config.installId,
+      ttlSeconds: config.tokenTtlSeconds ?? DEFAULT_TOKEN_TTL_SECONDS,
+      leewaySeconds: config.tokenRefreshLeewaySeconds ?? DEFAULT_TOKEN_REFRESH_LEEWAY_SECONDS
+    });
+    this.client = new GraphQLClient({
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      appId: config.appId,
+      gatewayKey: config.gatewayKey,
+      getToken: () => tokens.getToken(),
+      retryDelaysMs: config.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS,
+      logger,
+      fetchFn: config.fetch ?? globalThis.fetch
+    });
+    this.productServiceOptions = {
+      itemOptionsPageSize: config.itemOptionsPageSize
+    };
+  }
+  /**
+   * Returns the {@link ProductService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getProductService() {
+    if (!this.productService) {
+      this.productService = new ProductService(
+        this.client,
+        this.productServiceOptions
+      );
+    }
+    return this.productService;
+  }
+  /**
+   * Returns the {@link AccountUserService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getAccountUserService() {
+    if (!this.accountUserService) {
+      this.accountUserService = new AccountUserService(this.client);
+    }
+    return this.accountUserService;
+  }
+  /**
+   * Returns the {@link ResourcePoolService} for this install, bound to the
+   * shared authenticated transport. The instance is created lazily and reused.
+   */
+  getResourcePoolService() {
+    if (!this.resourcePoolService) {
+      this.resourcePoolService = new ResourcePoolService(this.client);
+    }
+    return this.resourcePoolService;
+  }
+  /**
+   * Returns the {@link TimeslotService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused; its
+   * guide assignment composes the resource-pool and account-user services.
+   */
+  getTimeslotService() {
+    if (!this.timeslotService) {
+      this.timeslotService = new TimeslotService(this.client, {
+        resourcePoolService: this.getResourcePoolService(),
+        accountUserService: this.getAccountUserService()
+      });
+    }
+    return this.timeslotService;
+  }
+  /**
+   * Returns the {@link ResellerService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getResellerService() {
+    if (!this.resellerService) {
+      this.resellerService = new ResellerService(this.client);
+    }
+    return this.resellerService;
+  }
+  /**
+   * Returns the {@link PromoCodeService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getPromoCodeService() {
+    if (!this.promoCodeService) {
+      this.promoCodeService = new PromoCodeService(this.client);
+    }
+    return this.promoCodeService;
+  }
+  /**
+   * Returns the {@link DailyNoteService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getDailyNoteService() {
+    if (!this.dailyNoteService) {
+      this.dailyNoteService = new DailyNoteService(this.client);
+    }
+    return this.dailyNoteService;
+  }
+  /**
+   * Returns the {@link AvailabilityService} for this install, bound to the
+   * shared authenticated transport. The instance is created lazily and reused.
+   */
+  getAvailabilityService() {
+    if (!this.availabilityService) {
+      this.availabilityService = new AvailabilityService(this.client);
+    }
+    return this.availabilityService;
+  }
+  /**
+   * Returns the {@link MembershipService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getMembershipService() {
+    if (!this.membershipService) {
+      this.membershipService = new MembershipService(this.client);
+    }
+    return this.membershipService;
+  }
+  /**
+   * Returns the {@link BookingService} for this install, bound to the shared
+   * authenticated transport. The instance is created lazily and reused.
+   */
+  getBookingService() {
+    if (!this.bookingService) {
+      this.bookingService = new BookingService(this.client, {
+        productService: this.getProductService()
+      });
+    }
+    return this.bookingService;
+  }
+};
+function requireNonEmpty(value, name) {
+  if (!value) {
+    throw new Error(`PeekAccessService: "${name}" is required`);
+  }
+}
+
+export { ADD_ON_PRODUCT_TYPE, AccountUserService, AdminAccountRequiredError, AvailabilityService, BookingService, DailyNoteService, MembershipService, PeekAccessService, PeekGraphQLError, ProductService, PromoCodeService, RateLimitError, ResellerService, ResourcePoolService, TimeslotService, noopLogger };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map