@atzentis/booking-sdk 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -28,8 +28,12 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var index_exports = {};
 __export(index_exports, {
   AuthenticationError: () => AuthenticationError,
+  AvailabilityService: () => AvailabilityService,
+  BOOKING_STATUSES: () => BOOKING_STATUSES,
+  BOOKING_TYPES: () => BOOKING_TYPES,
   BookingClient: () => BookingClient,
   BookingError: () => BookingError,
+  BookingsService: () => BookingsService,
   CategoriesService: () => CategoriesService,
   ConflictError: () => ConflictError,
   DEFAULT_MODULES: () => DEFAULT_MODULES,
@@ -523,6 +527,505 @@ var BaseService = class {
   }
 };
 
+// src/services/availability.ts
+var AvailabilityService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/booking/v1/availability";
+  }
+  /**
+   * Check availability for a property and date range.
+   *
+   * @param params - Must include `propertyId`, `checkIn`, `checkOut`; supports optional filters
+   *
+   * @example
+   * ```typescript
+   * const result = await booking.availability.check({
+   *   propertyId: "prop_abc123",
+   *   checkIn: "2025-06-01",
+   *   checkOut: "2025-06-05",
+   *   type: "room",
+   *   guests: 2,
+   * });
+   * ```
+   */
+  check(params) {
+    const { propertyId, checkIn, checkOut, categoryId, spaceId, guests, type } = params;
+    return this._get(this.basePath, {
+      propertyId,
+      checkIn,
+      checkOut,
+      categoryId,
+      spaceId,
+      guests,
+      type
+    });
+  }
+  /**
+   * Search availability across multiple properties.
+   *
+   * @param params - Must include `propertyIds`, `checkIn`, `checkOut`; supports filtering and pagination
+   *
+   * @example
+   * ```typescript
+   * const results = await booking.availability.search({
+   *   propertyIds: ["prop_abc", "prop_def"],
+   *   checkIn: "2025-06-01",
+   *   checkOut: "2025-06-05",
+   *   guests: 2,
+   *   priceRange: { min: 5000, max: 20000 },
+   * });
+   * ```
+   */
+  search(params) {
+    return this._post(this.basePath, params);
+  }
+  /**
+   * Generate a calendar view of daily availability for a property.
+   *
+   * Client-side helper that calls `check()` internally and transforms the result
+   * into a `CalendarDay[]` suitable for calendar UI rendering.
+   *
+   * @param params - Extends `AvailabilityCheckParams` with optional `months` (default: 1)
+   *
+   * @example
+   * ```typescript
+   * const calendar = await booking.availability.getCalendar({
+   *   propertyId: "prop_abc123",
+   *   checkIn: "2025-06-01",
+   *   checkOut: "2025-06-30",
+   * });
+   * ```
+   */
+  async getCalendar(params) {
+    const { months, ...checkParams } = params;
+    let endDate;
+    if (checkParams.checkOut !== checkParams.checkIn) {
+      endDate = checkParams.checkOut;
+    } else if (months != null) {
+      endDate = addDays(checkParams.checkIn, months * 30);
+    } else {
+      return [];
+    }
+    const dates = generateDateRange(checkParams.checkIn, endDate, 365);
+    if (dates.length === 0) return [];
+    const result = await this.check({ ...checkParams, checkOut: endDate });
+    const spacesAvailable = result.spaces.filter((s) => s.available).length;
+    return dates.map((date) => ({
+      date,
+      available: result.available,
+      price: result.available && result.pricing ? result.pricing.total : null,
+      minStay: result.restrictions?.minStay ?? null,
+      closedToArrival: result.restrictions?.closedToArrival ?? false,
+      closedToDeparture: result.restrictions?.closedToDeparture ?? false,
+      spacesAvailable: result.available ? spacesAvailable : 0
+    }));
+  }
+  /**
+   * Get available table reservation time slots for a specific date.
+   *
+   * Client-side helper for the Tables vertical. Calls `check()` internally
+   * with `type: "table"` and reshapes the response into `TimeSlot[]`.
+   *
+   * @param params - Must include `propertyId` and `date`
+   *
+   * @example
+   * ```typescript
+   * const slots = await booking.availability.getTableSlots({
+   *   propertyId: "prop_abc123",
+   *   date: "2025-06-15",
+   *   guests: 4,
+   * });
+   * ```
+   */
+  async getTableSlots(params) {
+    const { date, guests, categoryId, duration, ...rest } = params;
+    const result = await this.check({
+      ...rest,
+      checkIn: date,
+      checkOut: date,
+      type: "table",
+      guests,
+      categoryId
+    });
+    if (!result.available || result.spaces.length === 0) {
+      return [];
+    }
+    const slotDuration = duration ?? 90;
+    const availableSpaces = result.spaces.filter((s) => s.available);
+    return availableSpaces.map((space, index) => ({
+      startTime: minutesToTime(11 * 60 + index * slotDuration),
+      endTime: minutesToTime(11 * 60 + index * slotDuration + slotDuration),
+      available: true,
+      tablesAvailable: availableSpaces.length,
+      price: space.price
+    }));
+  }
+  /**
+   * Get available service appointment slots for a specific date.
+   *
+   * Client-side helper for the Services vertical. Calls `check()` internally
+   * with `type: "service"` and reshapes the response into `ServiceTimeSlot[]`.
+   *
+   * @param params - Must include `propertyId` and `date`
+   *
+   * @example
+   * ```typescript
+   * const slots = await booking.availability.getServiceSlots({
+   *   propertyId: "prop_abc123",
+   *   date: "2025-06-15",
+   *   providerId: "staff_001",
+   *   duration: 60,
+   * });
+   * ```
+   */
+  async getServiceSlots(params) {
+    const { date, providerId, categoryId, duration, ...rest } = params;
+    const result = await this.check({
+      ...rest,
+      checkIn: date,
+      checkOut: date,
+      type: "service",
+      categoryId
+    });
+    if (!result.available || result.spaces.length === 0) {
+      return [];
+    }
+    const slotDuration = duration ?? 60;
+    const availableSpaces = result.spaces.filter((s) => s.available);
+    return availableSpaces.map((space, index) => ({
+      startTime: minutesToTime(9 * 60 + index * slotDuration),
+      endTime: minutesToTime(9 * 60 + index * slotDuration + slotDuration),
+      available: true,
+      tablesAvailable: availableSpaces.length,
+      price: space.price,
+      providerId: providerId ?? space.spaceId,
+      providerName: space.name
+    }));
+  }
+  /**
+   * Get aggregated pricing statistics for a property and date range.
+   *
+   * Client-side helper that calls `check()` internally and computes
+   * min/max/average/total pricing from available spaces.
+   *
+   * @param params - Extends `AvailabilityCheckParams` with optional `currency`
+   *
+   * @example
+   * ```typescript
+   * const pricing = await booking.availability.getPricing({
+   *   propertyId: "prop_abc123",
+   *   checkIn: "2025-06-01",
+   *   checkOut: "2025-06-05",
+   * });
+   * console.log(`From €${pricing.minPrice / 100} to €${pricing.maxPrice / 100}`);
+   * ```
+   */
+  async getPricing(params) {
+    const { currency: requestedCurrency, ...checkParams } = params;
+    const result = await this.check(checkParams);
+    const availableSpaces = result.spaces.filter((s) => s.available);
+    const nights = dateDiffDays(params.checkIn, params.checkOut);
+    const currency = requestedCurrency ?? result.pricing?.currency ?? "EUR";
+    if (availableSpaces.length === 0) {
+      return {
+        minPrice: 0,
+        maxPrice: 0,
+        averagePrice: 0,
+        totalPrice: 0,
+        perNight: null,
+        nights,
+        currency
+      };
+    }
+    const prices = availableSpaces.map((s) => s.price);
+    const minPrice = Math.min(...prices);
+    const maxPrice = Math.max(...prices);
+    const averagePrice = Math.round(prices.reduce((sum, p) => sum + p, 0) / prices.length);
+    const totalPrice = result.pricing?.total ?? averagePrice * Math.max(nights, 1);
+    const perNight = nights > 0 ? Math.round(totalPrice / nights) : null;
+    return { minPrice, maxPrice, averagePrice, totalPrice, perNight, nights, currency };
+  }
+};
+function parseDateStr(dateStr) {
+  const parts = dateStr.split("-");
+  return [Number(parts[0]), Number(parts[1]), Number(parts[2])];
+}
+function addDays(dateStr, days) {
+  const [year, month, day] = parseDateStr(dateStr);
+  return formatDate(new Date(Date.UTC(year, month - 1, day + days)));
+}
+function generateDateRange(start, end, maxDays) {
+  const [sy, sm, sd] = parseDateStr(start);
+  const [ey, em, ed] = parseDateStr(end);
+  const startMs = Date.UTC(sy, sm - 1, sd);
+  const endMs = Date.UTC(ey, em - 1, ed);
+  if (endMs <= startMs) return [];
+  const msPerDay = 864e5;
+  const totalDays = Math.min(Math.floor((endMs - startMs) / msPerDay), maxDays);
+  const dates = [];
+  for (let i = 0; i < totalDays; i++) {
+    dates.push(formatDate(new Date(startMs + i * msPerDay)));
+  }
+  return dates;
+}
+function dateDiffDays(start, end) {
+  const [sy, sm, sd] = parseDateStr(start);
+  const [ey, em, ed] = parseDateStr(end);
+  const startMs = Date.UTC(sy, sm - 1, sd);
+  const endMs = Date.UTC(ey, em - 1, ed);
+  return Math.max(0, Math.floor((endMs - startMs) / 864e5));
+}
+function formatDate(d) {
+  const y = d.getUTCFullYear();
+  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function minutesToTime(totalMinutes) {
+  const hours = Math.floor(totalMinutes / 60) % 24;
+  const minutes = totalMinutes % 60;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`;
+}
+
+// src/services/bookings.ts
+var BookingsService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/booking/v1/bookings";
+  }
+  // ---------------------------------------------------------------------------
+  // CRUD
+  // ---------------------------------------------------------------------------
+  /**
+   * Create a new booking.
+   *
+   * @example
+   * ```typescript
+   * const booking = await client.bookings.create({
+   *   propertyId: "prop_abc123",
+   *   categoryId: "cat_deluxe",
+   *   guestId: "guest_42",
+   *   checkIn: "2025-07-01",
+   *   checkOut: "2025-07-05",
+   *   type: "stay",
+   *   guests: 2,
+   *   autoConfirm: true,
+   * });
+   * ```
+   */
+  create(input) {
+    return this._post(this.basePath, input);
+  }
+  /**
+   * Get a single booking by ID.
+   *
+   * @example
+   * ```typescript
+   * const booking = await client.bookings.get("bk_abc123");
+   * ```
+   */
+  get(bookingId) {
+    return this._get(this._buildPath(bookingId));
+  }
+  /**
+   * List bookings for a property with optional filters and cursor-based pagination.
+   *
+   * Supports filtering by status, type, guest, date ranges, search term,
+   * and custom sort order. Array values for `status` and `type` are serialized
+   * as comma-separated strings.
+   *
+   * @example
+   * ```typescript
+   * // List all confirmed stay bookings
+   * const page = await client.bookings.list({
+   *   propertyId: "prop_abc123",
+   *   status: "confirmed",
+   *   type: "stay",
+   * });
+   *
+   * // Multi-status filter with date range
+   * const page2 = await client.bookings.list({
+   *   propertyId: "prop_abc123",
+   *   status: ["confirmed", "checked_in"],
+   *   checkInFrom: "2025-07-01",
+   *   checkInTo: "2025-07-31",
+   *   sort: { field: "checkIn", direction: "asc" },
+   *   limit: 20,
+   * });
+   * ```
+   */
+  list(params) {
+    const query = {
+      propertyId: params.propertyId
+    };
+    if (params.status !== void 0) {
+      query.status = Array.isArray(params.status) ? params.status.join(",") : params.status;
+    }
+    if (params.type !== void 0) {
+      query.type = Array.isArray(params.type) ? params.type.join(",") : params.type;
+    }
+    if (params.guestId !== void 0) query.guestId = params.guestId;
+    if (params.checkInFrom !== void 0) query.checkInFrom = params.checkInFrom;
+    if (params.checkInTo !== void 0) query.checkInTo = params.checkInTo;
+    if (params.checkOutFrom !== void 0) query.checkOutFrom = params.checkOutFrom;
+    if (params.checkOutTo !== void 0) query.checkOutTo = params.checkOutTo;
+    if (params.search !== void 0) query.search = params.search;
+    if (params.sort !== void 0) {
+      query.sort = `${params.sort.field}:${params.sort.direction}`;
+    }
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this.basePath, query);
+  }
+  /**
+   * Update an existing booking.
+   *
+   * @example
+   * ```typescript
+   * const updated = await client.bookings.update("bk_abc123", {
+   *   guests: 3,
+   *   notes: "Extra bed requested",
+   * });
+   * ```
+   */
+  update(bookingId, input) {
+    return this._patch(this._buildPath(bookingId), input);
+  }
+  /**
+   * Delete a booking.
+   *
+   * @example
+   * ```typescript
+   * await client.bookings.delete("bk_abc123");
+   * ```
+   */
+  delete(bookingId) {
+    return this._delete(this._buildPath(bookingId));
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle — happy path
+  // ---------------------------------------------------------------------------
+  /**
+   * Confirm a pending booking.
+   *
+   * Transitions: `pending` → `confirmed`
+   *
+   * @throws {ConflictError} 409 if the booking is not in `pending` status
+   *
+   * @example
+   * ```typescript
+   * const confirmed = await client.bookings.confirm("bk_abc123");
+   * // confirmed.status === "confirmed"
+   * // confirmed.confirmedAt is populated
+   * ```
+   */
+  confirm(bookingId) {
+    return this._post(this._buildPath(bookingId, "confirm"), {});
+  }
+  /**
+   * Check in a guest.
+   *
+   * Transitions: `confirmed` → `checked_in`
+   *
+   * @throws {ConflictError} 409 if the booking is not in `confirmed` status
+   *
+   * @example
+   * ```typescript
+   * const checkedIn = await client.bookings.checkIn("bk_abc123", {
+   *   actualArrival: "2025-07-01T14:30:00Z",
+   * });
+   * // checkedIn.status === "checked_in"
+   * // checkedIn.checkedInAt is populated
+   * ```
+   */
+  checkIn(bookingId, input) {
+    return this._post(this._buildPath(bookingId, "check-in"), input ?? {});
+  }
+  /**
+   * Check out a guest.
+   *
+   * Transitions: `checked_in` → `checked_out`
+   *
+   * @throws {ConflictError} 409 if the booking is not in `checked_in` status
+   *
+   * @example
+   * ```typescript
+   * const checkedOut = await client.bookings.checkOut("bk_abc123", {
+   *   actualDeparture: "2025-07-05T11:00:00Z",
+   * });
+   * // checkedOut.status === "checked_out"
+   * // checkedOut.checkedOutAt is populated
+   * ```
+   */
+  checkOut(bookingId, input) {
+    return this._post(this._buildPath(bookingId, "check-out"), input ?? {});
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle — alternate endings
+  // ---------------------------------------------------------------------------
+  /**
+   * Cancel a booking.
+   *
+   * Transitions: `pending` | `confirmed` | `checked_in` → `cancelled`
+   *
+   * @throws {ConflictError} 409 if the booking is already cancelled, checked out, or no-show
+   *
+   * @example
+   * ```typescript
+   * const cancelled = await client.bookings.cancel("bk_abc123", {
+   *   reason: "Guest requested cancellation",
+   *   refundRequested: true,
+   * });
+   * // cancelled.status === "cancelled"
+   * // cancelled.cancelledAt is populated
+   * // cancelled.cancellationReason === "Guest requested cancellation"
+   * ```
+   */
+  cancel(bookingId, input) {
+    return this._post(this._buildPath(bookingId, "cancel"), input);
+  }
+  /**
+   * Mark a booking as no-show.
+   *
+   * Transitions: `pending` | `confirmed` | `checked_in` → `no_show`
+   *
+   * @throws {ConflictError} 409 if the booking is already checked out, cancelled, or no-show
+   *
+   * @example
+   * ```typescript
+   * const noShow = await client.bookings.noShow("bk_abc123", {
+   *   chargeNoShowFee: true,
+   * });
+   * // noShow.status === "no_show"
+   * // noShow.noShowAt is populated
+   * ```
+   */
+  noShow(bookingId, input) {
+    return this._post(this._buildPath(bookingId, "no-show"), input ?? {});
+  }
+  /**
+   * Assign or reassign a space to a booking.
+   *
+   * Can be called on any active booking (pending, confirmed, checked_in).
+   *
+   * @throws {ConflictError} 409 if the booking is in a terminal status
+   *
+   * @example
+   * ```typescript
+   * const assigned = await client.bookings.assignSpace("bk_abc123", {
+   *   spaceId: "spc_room101",
+   *   notes: "Upgraded to deluxe",
+   * });
+   * // assigned.spaceId === "spc_room101"
+   * // assigned.space is populated
+   * ```
+   */
+  assignSpace(bookingId, input) {
+    return this._post(this._buildPath(bookingId, "assign-space"), input);
+  }
+};
+
 // src/services/categories.ts
 var CategoriesService = class extends BaseService {
   constructor() {
@@ -807,6 +1310,16 @@ var BookingClient = class {
       logger: validated.logger
     });
   }
+  /** Availability service — lazy-initialized on first access */
+  get availability() {
+    this._availability ?? (this._availability = new AvailabilityService(this.httpClient));
+    return this._availability;
+  }
+  /** Bookings service — lazy-initialized on first access */
+  get bookings() {
+    this._bookings ?? (this._bookings = new BookingsService(this.httpClient));
+    return this._bookings;
+  }
   /** Properties service — lazy-initialized on first access */
   get properties() {
     this._properties ?? (this._properties = new PropertiesService(this.httpClient));
@@ -861,6 +1374,27 @@ async function firstPage(fetcher, options) {
   return fetcher({ ...options ?? {} });
 }
 
+// src/types/bookings.ts
+var BOOKING_TYPES = [
+  "stay",
+  "table",
+  "service",
+  "parking",
+  "desk",
+  "meeting",
+  "dayuse",
+  "custom"
+];
+var BOOKING_STATUSES = [
+  "pending",
+  "confirmed",
+  "checked_in",
+  "checked_out",
+  "cancelled",
+  "no_show",
+  "waitlist"
+];
+
 // src/types/properties.ts
 var PROPERTY_MODULES = [
   "booking",
@@ -910,8 +1444,12 @@ var VERSION = "0.1.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthenticationError,
+  AvailabilityService,
+  BOOKING_STATUSES,
+  BOOKING_TYPES,
   BookingClient,
   BookingError,
+  BookingsService,
   CategoriesService,
   ConflictError,
   DEFAULT_MODULES,