@atzentis/booking-sdk 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -28,6 +28,7 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var index_exports = {};
 __export(index_exports, {
   AuthenticationError: () => AuthenticationError,
+  AvailabilityService: () => AvailabilityService,
   BookingClient: () => BookingClient,
   BookingError: () => BookingError,
   CategoriesService: () => CategoriesService,
@@ -40,7 +41,10 @@ __export(index_exports, {
   PaymentError: () => PaymentError,
   PropertiesService: () => PropertiesService,
   RateLimitError: () => RateLimitError,
+  SPACE_STATUSES: () => SPACE_STATUSES,
+  SPACE_TYPES: () => SPACE_TYPES,
   ServerError: () => ServerError,
+  SpacesService: () => SpacesService,
   TimeoutError: () => TimeoutError,
   VERSION: () => VERSION,
   ValidationError: () => ValidationError,
@@ -520,6 +524,267 @@ 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/categories.ts
 var CategoriesService = class extends BaseService {
   constructor() {
@@ -658,6 +923,135 @@ var PropertiesService = class extends BaseService {
   }
 };
 
+// src/services/spaces.ts
+var SpacesService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/inventory/v1/spaces";
+  }
+  /**
+   * Create a new space.
+   *
+   * @example
+   * ```typescript
+   * const space = await booking.spaces.create({
+   *   propertyId: "prop_abc123",
+   *   name: "Room 101",
+   *   type: "room",
+   *   floor: "1",
+   *   capacity: 2,
+   * });
+   * ```
+   */
+  create(input) {
+    return this._post(this.basePath, input);
+  }
+  /**
+   * List spaces for a property with optional filters and cursor-based pagination.
+   *
+   * @param params - Must include `propertyId`; supports optional `type`, `status`, `categoryId`, `floor` filters
+   *
+   * @example
+   * ```typescript
+   * const page = await booking.spaces.list({
+   *   propertyId: "prop_abc123",
+   *   type: "room",
+   *   status: "available",
+   *   limit: 20,
+   * });
+   * ```
+   */
+  list(params) {
+    return this._list(params);
+  }
+  /**
+   * Get a single space by ID.
+   *
+   * @example
+   * ```typescript
+   * const space = await booking.spaces.get("spc_abc123");
+   * ```
+   */
+  get(spaceId) {
+    return this._get(this._buildPath(spaceId));
+  }
+  /**
+   * Update an existing space.
+   *
+   * @example
+   * ```typescript
+   * const updated = await booking.spaces.update("spc_abc123", {
+   *   name: "Room 101 Deluxe",
+   *   capacity: 3,
+   * });
+   * ```
+   */
+  update(spaceId, input) {
+    return this._patch(this._buildPath(spaceId), input);
+  }
+  /**
+   * Delete a space.
+   *
+   * @example
+   * ```typescript
+   * await booking.spaces.delete("spc_abc123");
+   * ```
+   */
+  delete(spaceId) {
+    return this._delete(this._buildPath(spaceId));
+  }
+  /**
+   * Bulk create multiple spaces for a property in a single API call.
+   *
+   * @example
+   * ```typescript
+   * const spaces = await booking.spaces.bulkCreate("prop_abc123", [
+   *   { propertyId: "prop_abc123", name: "Room 101", type: "room" },
+   *   { propertyId: "prop_abc123", name: "Room 102", type: "room" },
+   * ]);
+   * ```
+   */
+  bulkCreate(propertyId, spaces) {
+    return this._post(this._buildPath("bulk"), {
+      propertyId,
+      spaces
+    });
+  }
+  /**
+   * Bulk update multiple spaces for a property in a single API call.
+   *
+   * @example
+   * ```typescript
+   * const updated = await booking.spaces.bulkUpdate("prop_abc123", [
+   *   { id: "spc_1", name: "Room 101 Deluxe" },
+   *   { id: "spc_2", capacity: 3 },
+   * ]);
+   * ```
+   */
+  bulkUpdate(propertyId, updates) {
+    return this._patch(this._buildPath("bulk"), {
+      propertyId,
+      updates
+    });
+  }
+  /**
+   * Link a space to a POS table. Tables vertical only.
+   *
+   * Creates a cross-domain bridge between the inventory service and the POS system,
+   * enabling a space to reference its physical POS table.
+   *
+   * @example
+   * ```typescript
+   * const linked = await booking.spaces.linkPosTable("spc_abc123", {
+   *   posTableId: "pos_table_42",
+   * });
+   * ```
+   */
+  linkPosTable(spaceId, input) {
+    return this._post(this._buildPath(spaceId, "pos-table"), input);
+  }
+};
+
 // src/client.ts
 var BookingClient = class {
   constructor(config) {
@@ -675,6 +1069,11 @@ 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;
+  }
   /** Properties service — lazy-initialized on first access */
   get properties() {
     this._properties ?? (this._properties = new PropertiesService(this.httpClient));
@@ -685,6 +1084,11 @@ var BookingClient = class {
     this._categories ?? (this._categories = new CategoriesService(this.httpClient));
     return this._categories;
   }
+  /** Spaces service — lazy-initialized on first access */
+  get spaces() {
+    this._spaces ?? (this._spaces = new SpacesService(this.httpClient));
+    return this._spaces;
+  }
   setApiKey(key) {
     if (!key || key.trim().length === 0) {
       throw new Error("apiKey must be a non-empty string");
@@ -748,11 +1152,32 @@ var DEFAULT_MODULES = {
   pos: false
 };
 
+// src/types/spaces.ts
+var SPACE_TYPES = [
+  "room",
+  "table",
+  "sunbed",
+  "parking",
+  "desk",
+  "meeting_room",
+  "locker",
+  "service",
+  "custom"
+];
+var SPACE_STATUSES = [
+  "available",
+  "occupied",
+  "maintenance",
+  "blocked",
+  "inactive"
+];
+
 // src/index.ts
 var VERSION = "0.1.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthenticationError,
+  AvailabilityService,
   BookingClient,
   BookingError,
   CategoriesService,
@@ -765,7 +1190,10 @@ var VERSION = "0.1.0";
   PaymentError,
   PropertiesService,
   RateLimitError,
+  SPACE_STATUSES,
+  SPACE_TYPES,
   ServerError,
+  SpacesService,
   TimeoutError,
   VERSION,
   ValidationError,