@atzentis/booking-sdk 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -35,35 +35,48 @@ __export(index_exports, {
   BookingError: () => BookingError,
   BookingsService: () => BookingsService,
   CategoriesService: () => CategoriesService,
+  ConciergeService: () => ConciergeService,
   ConflictError: () => ConflictError,
   DEFAULT_MODULES: () => DEFAULT_MODULES,
   DiscountsService: () => DiscountsService,
   DistributionService: () => DistributionService,
   FinanceService: () => FinanceService,
+  FiscalService: () => FiscalService,
   ForbiddenError: () => ForbiddenError,
   GroupsService: () => GroupsService,
   GuestsService: () => GuestsService,
   HousekeepingService: () => HousekeepingService,
   HttpClient: () => HttpClient,
+  IdScanningService: () => IdScanningService,
+  IntelligenceService: () => IntelligenceService,
   NightAuditService: () => NightAuditService,
   NotFoundError: () => NotFoundError,
+  NotificationsService: () => NotificationsService,
   PROPERTY_MODULES: () => PROPERTY_MODULES,
   PaymentError: () => PaymentError,
   PaymentsService: () => PaymentsService,
+  PortfoliosService: () => PortfoliosService,
   PropertiesService: () => PropertiesService,
   RateLimitError: () => RateLimitError,
   RatePlansService: () => RatePlansService,
+  RevenueService: () => RevenueService,
   ReviewsService: () => ReviewsService,
   SPACE_STATUSES: () => SPACE_STATUSES,
   SPACE_TYPES: () => SPACE_TYPES,
+  SSEClient: () => SSEClient,
   ServerError: () => ServerError,
+  ServicesHelper: () => ServicesHelper,
+  SettingsService: () => SettingsService,
   SpacesService: () => SpacesService,
   StaffService: () => StaffService,
+  StaysHelper: () => StaysHelper,
   SupplyService: () => SupplyService,
+  TablesHelper: () => TablesHelper,
   TasksService: () => TasksService,
   TimeoutError: () => TimeoutError,
   VERSION: () => VERSION,
   ValidationError: () => ValidationError,
+  WebhooksService: () => WebhooksService,
   bookingClientConfigSchema: () => bookingClientConfigSchema,
   createErrorFromResponse: () => createErrorFromResponse,
   firstPage: () => firstPage,
@@ -1104,6 +1117,104 @@ var CategoriesService = class extends BaseService {
   }
 };
 
+// src/services/concierge.ts
+var ConciergeService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/concierge/v1";
+  }
+  // ---------------------------------------------------------------------------
+  // Conversations
+  // ---------------------------------------------------------------------------
+  /** Create a new guest conversation */
+  createConversation(input) {
+    return this._post(this._buildPath("conversations"), input);
+  }
+  /** Get a conversation by ID */
+  getConversation(conversationId) {
+    return this._get(this._buildPath("conversations", conversationId));
+  }
+  /** List conversations with optional filters */
+  listConversations(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    if (params.guestId !== void 0) query.guestId = params.guestId;
+    if (params.status !== void 0) query.status = params.status;
+    if (params.channel !== void 0) query.channel = params.channel;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.sortBy !== void 0) query.sortBy = params.sortBy;
+    if (params.sortOrder !== void 0) query.sortOrder = params.sortOrder;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("conversations"), query);
+  }
+  // ---------------------------------------------------------------------------
+  // Messages
+  // ---------------------------------------------------------------------------
+  /** Send a message in a conversation */
+  sendMessage(conversationId, input) {
+    return this._post(
+      this._buildPath("conversations", conversationId, "messages"),
+      input
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Context & Escalation
+  // ---------------------------------------------------------------------------
+  /** Get the full context for a conversation (property, guest, booking, FAQ) */
+  getContext(conversationId) {
+    return this._get(
+      this._buildPath("conversations", conversationId, "context")
+    );
+  }
+  /** Escalate a conversation to staff */
+  escalate(conversationId, input) {
+    return this._post(
+      this._buildPath("conversations", conversationId, "escalate"),
+      input ?? {}
+    );
+  }
+  /** Resolve a conversation */
+  resolve(conversationId, input) {
+    return this._post(
+      this._buildPath("conversations", conversationId, "resolve"),
+      input ?? {}
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Templates
+  // ---------------------------------------------------------------------------
+  /** Create a response template */
+  createTemplate(input) {
+    return this._post(this._buildPath("templates"), input);
+  }
+  /** Get a template by ID */
+  getTemplate(templateId) {
+    return this._get(this._buildPath("templates", templateId));
+  }
+  /** List templates with optional filters */
+  listTemplates(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    if (params.category !== void 0) query.category = params.category;
+    if (params.language !== void 0) query.language = params.language;
+    if (params.sortBy !== void 0) query.sortBy = params.sortBy;
+    if (params.sortOrder !== void 0) query.sortOrder = params.sortOrder;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("templates"), query);
+  }
+  /** Update a template */
+  updateTemplate(templateId, input) {
+    return this._patch(this._buildPath("templates", templateId), input);
+  }
+  /** Delete a template */
+  deleteTemplate(templateId) {
+    return this._delete(this._buildPath("templates", templateId));
+  }
+};
+
 // src/services/discounts.ts
 var DiscountsService = class extends BaseService {
   constructor() {
@@ -1429,6 +1540,77 @@ var FinanceService = class extends BaseService {
   }
 };
 
+// src/services/fiscal.ts
+var FiscalService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/fiscal/v1";
+  }
+  // ---------------------------------------------------------------------------
+  // myDATA (Greek fiscal compliance)
+  // ---------------------------------------------------------------------------
+  /** Get the current myDATA integration status */
+  getMyDataStatus() {
+    return this._get(this._buildPath("mydata", "status"));
+  }
+  /** Submit an invoice to the Greek AADE myDATA platform */
+  submitMyData(input) {
+    return this._post(this._buildPath("mydata", "submit"), input);
+  }
+  /** List myDATA submissions with optional filters */
+  listMyDataSubmissions(params) {
+    if (!params) {
+      return this._get(this._buildPath("mydata", "submissions"));
+    }
+    const query = {};
+    if (params.status !== void 0) query.status = params.status;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("mydata", "submissions"), query);
+  }
+  /** Get a single myDATA submission by ID */
+  getMyDataSubmission(submissionId) {
+    return this._get(this._buildPath("mydata", "submissions", submissionId));
+  }
+  /** Generate a QR code for a myDATA transaction */
+  getMyDataQr(transactionId) {
+    return this._get(this._buildPath("mydata", "qr", transactionId));
+  }
+  // ---------------------------------------------------------------------------
+  // TSE (German fiscal compliance)
+  // ---------------------------------------------------------------------------
+  /** Get the current TSE device status */
+  getTseStatus() {
+    return this._get(this._buildPath("tse", "status"));
+  }
+  /** List TSE transactions with optional filters */
+  listTseTransactions(params) {
+    if (!params) {
+      return this._get(this._buildPath("tse", "transactions"));
+    }
+    const query = {};
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("tse", "transactions"), query);
+  }
+  /** Trigger a TSE day closure */
+  tseDayClosure(input) {
+    return this._post(this._buildPath("tse", "day-closure"), input ?? {});
+  }
+  /** Export DSFinV-K data for a date range */
+  tseExportDsfinvk(params) {
+    const query = {};
+    query.from = params.from;
+    query.to = params.to;
+    if (params.format !== void 0) query.format = params.format;
+    return this._get(this._buildPath("tse", "export", "dsfinvk"), query);
+  }
+};
+
 // src/services/groups.ts
 var GroupsService = class extends BaseService {
   constructor() {
@@ -1825,6 +2007,77 @@ var HousekeepingService = class extends BaseService {
   }
 };
 
+// src/services/id-scanning.ts
+var IdScanningService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/guest/v1/id-scans";
+  }
+  /** Upload a document image for OCR processing */
+  upload(input) {
+    const formData = new FormData();
+    formData.append("guestId", input.guestId);
+    formData.append(
+      "file",
+      input.file instanceof ArrayBuffer ? new Blob([input.file]) : input.file
+    );
+    formData.append("type", input.type);
+    return this._post(this.basePath, formData);
+  }
+  /** Get the OCR result for a scan by ID */
+  getResult(scanId) {
+    return this._get(this._buildPath(scanId));
+  }
+  /** List ID scans with optional filters */
+  list(params) {
+    const query = {};
+    query.guestId = params.guestId;
+    if (params.status !== void 0) query.status = params.status;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this.basePath, query);
+  }
+};
+
+// src/services/intelligence.ts
+var IntelligenceService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/guest/v1";
+  }
+  // ---------------------------------------------------------------------------
+  // Profile
+  // ---------------------------------------------------------------------------
+  /** Get the intelligence profile for a guest */
+  getProfile(guestId) {
+    return this._get(this._buildPath("profiles", guestId, "intelligence"));
+  }
+  /** Trigger a refresh of the intelligence profile for a guest */
+  refresh(guestId) {
+    return this._post(
+      this._buildPath("profiles", guestId, "intelligence", "refresh"),
+      {}
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  /** Ingest a guest intelligence event for processing */
+  ingestEvent(input) {
+    return this._post(this._buildPath("intelligence", "events"), input);
+  }
+  /** List intelligence events for a guest with optional filters */
+  listEvents(params) {
+    const query = {};
+    query.guestId = params.guestId;
+    if (params.status !== void 0) query.status = params.status;
+    if (params.type !== void 0) query.type = params.type;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("intelligence", "events"), query);
+  }
+};
+
 // src/services/night-audit.ts
 var NightAuditService = class extends BaseService {
   constructor() {
@@ -1859,6 +2112,26 @@ var NightAuditService = class extends BaseService {
   }
 };
 
+// src/services/notifications.ts
+var NotificationsService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/notifications/v1";
+  }
+  /** Get notification preferences for a guest */
+  getPreferences(guestId) {
+    return this._get(this._buildPath("preferences", guestId));
+  }
+  /** Update notification preferences for a guest */
+  updatePreferences(guestId, input) {
+    return this._patch(this._buildPath("preferences", guestId), input);
+  }
+  /** Opt a guest out of notifications (all channels or specific ones) */
+  optOut(input) {
+    return this._post(this._buildPath("opt-out"), input);
+  }
+};
+
 // src/services/payments.ts
 var PaymentsService = class extends BaseService {
   constructor() {
@@ -1954,6 +2227,77 @@ var PaymentsService = class extends BaseService {
   }
 };
 
+// src/services/portfolios.ts
+var PortfoliosService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/operations/v1/portfolios";
+  }
+  // ---------------------------------------------------------------------------
+  // CRUD
+  // ---------------------------------------------------------------------------
+  /** Create a new portfolio */
+  create(input) {
+    return this._post(this.basePath, input);
+  }
+  /** Get a portfolio by ID including its properties */
+  get(portfolioId) {
+    return this._get(this._buildPath(portfolioId));
+  }
+  /** List portfolios with optional filters */
+  list(params) {
+    if (!params) return this._get(this.basePath);
+    const query = {};
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    if (params.search !== void 0) query.search = params.search;
+    return this._get(this.basePath, query);
+  }
+  /** Update a portfolio */
+  update(portfolioId, input) {
+    return this._patch(this._buildPath(portfolioId), input);
+  }
+  /** Delete a portfolio */
+  delete(portfolioId) {
+    return this._delete(this._buildPath(portfolioId));
+  }
+  // ---------------------------------------------------------------------------
+  // Membership
+  // ---------------------------------------------------------------------------
+  /** Add a property to a portfolio */
+  addProperty(portfolioId, input) {
+    return this._post(this._buildPath(portfolioId, "properties"), input);
+  }
+  /** Remove a property from a portfolio */
+  removeProperty(portfolioId, propertyId) {
+    return this._delete(this._buildPath(portfolioId, "properties", propertyId));
+  }
+  // ---------------------------------------------------------------------------
+  // Dashboard
+  // ---------------------------------------------------------------------------
+  /** Get aggregated dashboard data for a portfolio */
+  getDashboard(portfolioId, params) {
+    const path = this._buildPath(portfolioId, "dashboard");
+    if (!params) return this._get(path);
+    const query = {};
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    return this._get(path, query);
+  }
+  // ---------------------------------------------------------------------------
+  // Search
+  // ---------------------------------------------------------------------------
+  /** Search for guests, bookings, or all records within a portfolio */
+  search(portfolioId, params) {
+    const query = {};
+    query.query = params.query;
+    if (params.type !== void 0) query.type = params.type;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath(portfolioId, "search"), query);
+  }
+};
+
 // src/services/properties.ts
 var PropertiesService = class extends BaseService {
   constructor() {
@@ -2121,6 +2465,152 @@ var RatePlansService = class extends BaseService {
   }
 };
 
+// src/services/revenue.ts
+var RevenueService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/revenue/v1";
+  }
+  // ---------------------------------------------------------------------------
+  // Dashboard
+  // ---------------------------------------------------------------------------
+  /** Get the revenue dashboard with KPIs, occupancy, and revenue breakdown */
+  getDashboard(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.compareWith !== void 0) query.compareWith = params.compareWith;
+    return this._get(this._buildPath("dashboard"), query);
+  }
+  /** Get individual KPI metrics with optional granularity breakdown */
+  getKPIs(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.metrics !== void 0) query.metrics = params.metrics.join(",");
+    if (params.granularity !== void 0) query.granularity = params.granularity;
+    return this._get(this._buildPath("kpis"), query);
+  }
+  // ---------------------------------------------------------------------------
+  // Rate suggestions
+  // ---------------------------------------------------------------------------
+  /** List AI-generated rate suggestions with optional filters */
+  listSuggestions(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    if (params.status !== void 0) query.status = params.status;
+    if (params.ratePlanId !== void 0) query.ratePlanId = params.ratePlanId;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("suggestions"), query);
+  }
+  /** Apply a rate suggestion, updating the associated rate plan */
+  applySuggestion(suggestionId) {
+    return this._post(this._buildPath("suggestions", suggestionId, "apply"), {});
+  }
+  /** Dismiss a rate suggestion with an optional reason */
+  dismissSuggestion(suggestionId, input) {
+    return this._post(
+      this._buildPath("suggestions", suggestionId, "dismiss"),
+      input ?? {}
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Competitors
+  // ---------------------------------------------------------------------------
+  /** List competitors tracked for a property */
+  listCompetitors(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("competitors"), query);
+  }
+  /** Get rate data scraped for a competitor over a date range */
+  getCompetitorRates(competitorId, params) {
+    const query = {};
+    if (params !== void 0) {
+      if (params.from !== void 0) query.from = params.from;
+      if (params.to !== void 0) query.to = params.to;
+      if (params.source !== void 0) query.source = params.source;
+    }
+    return this._get(
+      this._buildPath("competitors", competitorId, "rates"),
+      query
+    );
+  }
+  /** Add a competitor to track for a property */
+  addCompetitor(input) {
+    return this._post(this._buildPath("competitors"), input);
+  }
+  // ---------------------------------------------------------------------------
+  // Reports
+  // ---------------------------------------------------------------------------
+  /** Get a detailed revenue report with optional comparison period */
+  getRevenueReport(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    query.from = params.from;
+    query.to = params.to;
+    if (params.groupBy !== void 0) query.groupBy = params.groupBy;
+    if (params.compareWith !== void 0) query.compareWith = params.compareWith;
+    return this._get(this._buildPath("reports", "revenue"), query);
+  }
+  /** Get a revenue forecast for a future date range */
+  getForecast(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    query.from = params.from;
+    query.to = params.to;
+    if (params.model !== void 0) query.model = params.model;
+    return this._get(this._buildPath("reports", "forecast"), query);
+  }
+  /** Get a pace report comparing current bookings against a prior period */
+  getPaceReport(params) {
+    const query = {};
+    query.propertyId = params.propertyId;
+    query.from = params.from;
+    query.to = params.to;
+    if (params.compareWith !== void 0) query.compareWith = params.compareWith;
+    if (params.granularity !== void 0) query.granularity = params.granularity;
+    return this._get(this._buildPath("reports", "pace"), query);
+  }
+  // ---------------------------------------------------------------------------
+  // Portfolio
+  // ---------------------------------------------------------------------------
+  /** Get a portfolio-level dashboard with aggregated KPIs */
+  getPortfolioDashboard(params) {
+    const query = {};
+    query.portfolioId = params.portfolioId;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    return this._get(this._buildPath("portfolio", "dashboard"), query);
+  }
+  /** Get a per-property breakdown of revenue metrics across a portfolio */
+  getPortfolioBreakdown(params) {
+    const query = {};
+    query.portfolioId = params.portfolioId;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.sortBy !== void 0) query.sortBy = params.sortBy;
+    if (params.sortOrder !== void 0) query.sortOrder = params.sortOrder;
+    return this._get(this._buildPath("portfolio", "breakdown"), query);
+  }
+  /** Get a revenue forecast for all properties in a portfolio */
+  getPortfolioForecast(params) {
+    const query = {};
+    query.portfolioId = params.portfolioId;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.model !== void 0) query.model = params.model;
+    return this._get(this._buildPath("portfolio", "forecast"), query);
+  }
+};
+
 // src/services/reviews.ts
 var ReviewsService = class extends BaseService {
   constructor() {
@@ -2206,6 +2696,195 @@ var ReviewsService = class extends BaseService {
   }
 };
 
+// src/services/services-helper.ts
+var ServicesHelper = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Book a service appointment in a single call.
+   *
+   * Orchestrates three steps:
+   * 1. `client.availability.getServiceSlots()` — verify available slots for the date
+   * 2. `client.guests.create()` — create the guest if inline data was provided
+   * 3. `client.bookings.create()` — create and auto-confirm the appointment booking
+   *
+   * @throws {Error} if no appointment slots are available for the requested date
+   */
+  async bookAppointment(input) {
+    const slots = await this.client.availability.getServiceSlots({
+      propertyId: input.propertyId,
+      date: input.date,
+      providerId: input.providerId,
+      categoryId: input.categoryId,
+      duration: input.duration ?? 60
+    });
+    if (slots.length === 0) {
+      throw new Error("No appointment slots available");
+    }
+    const guestId = typeof input.guest === "string" ? input.guest : (await this.client.guests.create(input.guest)).id;
+    const duration = input.duration ?? 60;
+    const checkIn = toISODateTime(input.date, input.time);
+    const checkOut = toISODateTime(input.date, addMinutes(input.time, duration));
+    const booking = await this.client.bookings.create({
+      propertyId: input.propertyId,
+      categoryId: input.categoryId,
+      guestId,
+      checkIn,
+      checkOut,
+      type: "service",
+      notes: input.notes,
+      autoConfirm: true
+    });
+    return { booking, guestId };
+  }
+  /**
+   * Get available service appointment slots for a specific date.
+   *
+   * Delegates to `client.availability.getServiceSlots()`.
+   */
+  async getSlots(params) {
+    return this.client.availability.getServiceSlots(params);
+  }
+  /**
+   * Get the service menu for a property — all bookable service categories with
+   * their base price and default duration.
+   *
+   * Calls `client.categories.list()` and maps each `SpaceCategory` to a
+   * `ServiceMenuItem`. The `maxOccupancy` field on categories is used as the
+   * default appointment duration for the Services vertical.
+   */
+  async getMenu(propertyId) {
+    const result = await this.client.categories.list({ propertyId });
+    return result.data.map((cat) => ({
+      categoryId: cat.id,
+      name: cat.name,
+      description: cat.description ?? null,
+      basePrice: cat.basePrice,
+      // For the Services vertical, maxOccupancy stores the default duration
+      duration: cat.maxOccupancy ?? null
+    }));
+  }
+  /**
+   * Get a provider's availability schedule across a date range.
+   *
+   * Calls `client.availability.getServiceSlots()` once per day from `from` to
+   * `to` (exclusive), capped at 31 days. Each day is returned as a
+   * `ProviderScheduleDay` with its individual time slots.
+   *
+   * @param params.from - Start date in YYYY-MM-DD format (inclusive)
+   * @param params.to - End date in YYYY-MM-DD format (exclusive, max 31 days from `from`)
+   */
+  async getProviderSchedule(params) {
+    const days = dateDiffDays2(params.from, params.to);
+    const cappedDays = Math.min(days, 31);
+    const schedule = [];
+    for (let i = 0; i < cappedDays; i++) {
+      const date = addDaysToDate(params.from, i);
+      const slots = await this.client.availability.getServiceSlots({
+        propertyId: params.propertyId,
+        date,
+        providerId: params.providerId
+      });
+      schedule.push({
+        date,
+        slots: slots.map((s) => ({
+          startTime: s.startTime,
+          endTime: s.endTime,
+          available: s.available
+        }))
+      });
+    }
+    return schedule;
+  }
+  /**
+   * Reschedule an existing appointment to a new date and time.
+   *
+   * Verifies slot availability for the new datetime via
+   * `client.availability.getServiceSlots()`, then updates the booking via
+   * `client.bookings.update()`.
+   *
+   * @throws {Error} if no slots are available for the new date/time
+   */
+  async reschedule(input) {
+    const current = await this.client.bookings.get(input.bookingId);
+    const duration = input.duration ?? 60;
+    const slots = await this.client.availability.getServiceSlots({
+      propertyId: current.propertyId,
+      date: input.newDate,
+      categoryId: current.categoryId ?? void 0,
+      duration
+    });
+    if (slots.length === 0) {
+      throw new Error("No slots available for new time");
+    }
+    const checkIn = toISODateTime(input.newDate, input.newTime);
+    const checkOut = toISODateTime(input.newDate, addMinutes(input.newTime, duration));
+    return this.client.bookings.update(input.bookingId, {
+      checkIn,
+      checkOut
+    });
+  }
+};
+function toDateString(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function toISODateTime(date, time) {
+  return `${date}T${time}:00.000Z`;
+}
+function addMinutes(time, mins) {
+  const [hourStr, minuteStr] = time.split(":");
+  const totalMinutes = Number(hourStr) * 60 + Number(minuteStr) + mins;
+  const h = Math.floor(totalMinutes / 60) % 24;
+  const m = totalMinutes % 60;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+function dateDiffDays2(start, end) {
+  const parseDateStr2 = (s) => {
+    const parts = s.split("-");
+    return [Number(parts[0]), Number(parts[1]), Number(parts[2])];
+  };
+  const [sy, sm, sd] = parseDateStr2(start);
+  const [ey, em, ed] = parseDateStr2(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 addDaysToDate(dateStr, days) {
+  const parts = dateStr.split("-");
+  const year = Number(parts[0]);
+  const month = Number(parts[1]);
+  const day = Number(parts[2]);
+  return toDateString(new Date(Date.UTC(year, month - 1, day + days)));
+}
+
+// src/services/settings.ts
+var SettingsService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/settings/v1";
+  }
+  /** Get property-level settings */
+  getPropertySettings() {
+    return this._get(this._buildPath("property"));
+  }
+  /** Update property-level settings */
+  updatePropertySettings(input) {
+    return this._patch(this._buildPath("property"), input);
+  }
+  /** Get fiscal compliance settings (myDATA and TSE) */
+  getFiscalSettings() {
+    return this._get(this._buildPath("fiscal"));
+  }
+  /** Update fiscal compliance settings (myDATA and TSE) */
+  updateFiscalSettings(input) {
+    return this._patch(this._buildPath("fiscal"), input);
+  }
+};
+
 // src/services/spaces.ts
 var SpacesService = class extends BaseService {
   constructor() {
@@ -2398,6 +3077,157 @@ var StaffService = class extends BaseService {
   }
 };
 
+// src/services/stays.ts
+var StaysHelper = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Book a stay in a single call.
+   *
+   * Orchestrates four steps:
+   * 1. `client.availability.check()` — verify availability for the date range
+   * 2. `client.guests.create()` — create the guest if inline data was provided
+   * 3. `client.bookings.create()` — create the booking
+   * 4. `client.bookings.confirm()` — confirm if `autoConfirm` is true
+   *
+   * @throws {Error} if no availability exists for the requested dates
+   */
+  async book(input) {
+    const avail = await this.client.availability.check({
+      propertyId: input.propertyId,
+      categoryId: input.categoryId,
+      checkIn: input.checkIn,
+      checkOut: input.checkOut,
+      guests: input.guests,
+      spaceId: input.spaceId
+    });
+    if (!avail.available) {
+      throw new Error("No availability for requested dates");
+    }
+    const guestId = typeof input.guest === "string" ? input.guest : (await this.client.guests.create(input.guest)).id;
+    const booking = await this.client.bookings.create({
+      propertyId: input.propertyId,
+      categoryId: input.categoryId,
+      guestId,
+      checkIn: input.checkIn,
+      checkOut: input.checkOut,
+      type: "stay",
+      guests: input.guests,
+      spaceId: input.spaceId,
+      notes: input.notes,
+      source: input.source,
+      rateId: input.rateId
+    });
+    let confirmed = false;
+    if (input.autoConfirm) {
+      await this.client.bookings.confirm(booking.id);
+      confirmed = true;
+    }
+    return { booking, guestId, confirmed };
+  }
+  /**
+   * Extend the checkout date of an existing stay.
+   *
+   * Verifies availability for the extension period (original checkout → new
+   * checkout) via `client.availability.check()` before updating the booking
+   * via `client.bookings.update()`.
+   *
+   * @throws {Error} if no availability exists for the extension period
+   */
+  async extend(input) {
+    const current = await this.client.bookings.get(input.bookingId);
+    const avail = await this.client.availability.check({
+      propertyId: current.propertyId,
+      checkIn: current.checkOut,
+      checkOut: input.newCheckOut,
+      categoryId: current.categoryId ?? void 0,
+      spaceId: current.spaceId ?? void 0
+    });
+    if (!avail.available) {
+      throw new Error("No availability for extension period");
+    }
+    return this.client.bookings.update(input.bookingId, {
+      checkOut: input.newCheckOut
+    });
+  }
+  /**
+   * Check a guest out early.
+   *
+   * Updates the checkout date to today via `client.bookings.update()`, then
+   * performs the check-out lifecycle transition via `client.bookings.checkOut()`.
+   */
+  async earlyCheckout(input) {
+    const today = toDateString2(/* @__PURE__ */ new Date());
+    await this.client.bookings.update(input.bookingId, { checkOut: today });
+    return this.client.bookings.checkOut(input.bookingId, {
+      actualDeparture: input.actualDeparture,
+      notes: input.notes
+    });
+  }
+  /**
+   * Get all confirmed bookings arriving on a given date.
+   *
+   * Calls `client.bookings.list()` filtered by `status: "confirmed"`,
+   * `type: "stay"`, and `checkInFrom/checkInTo` equal to the target date.
+   *
+   * @param params.date - Defaults to today if not provided
+   */
+  async getArrivals(params) {
+    const date = params.date ?? toDateString2(/* @__PURE__ */ new Date());
+    const result = await this.client.bookings.list({
+      propertyId: params.propertyId,
+      status: "confirmed",
+      type: "stay",
+      checkInFrom: date,
+      checkInTo: date
+    });
+    return result.data;
+  }
+  /**
+   * Get all checked-in bookings departing on a given date.
+   *
+   * Calls `client.bookings.list()` filtered by `status: "checked_in"`,
+   * `type: "stay"`, and `checkOutFrom/checkOutTo` equal to the target date.
+   *
+   * @param params.date - Defaults to today if not provided
+   */
+  async getDepartures(params) {
+    const date = params.date ?? toDateString2(/* @__PURE__ */ new Date());
+    const result = await this.client.bookings.list({
+      propertyId: params.propertyId,
+      status: "checked_in",
+      type: "stay",
+      checkOutFrom: date,
+      checkOutTo: date
+    });
+    return result.data;
+  }
+  /**
+   * Get a composite summary for a booking — booking record plus its folio.
+   *
+   * Calls `client.bookings.get()` and `client.finance.listFolios()`. If the
+   * finance service fails (e.g., folio not found), the folio is set to `null`
+   * and no error is propagated.
+   */
+  async getSummary(bookingId) {
+    const booking = await this.client.bookings.get(bookingId);
+    let folio = null;
+    try {
+      const folios = await this.client.finance.listFolios({ bookingId });
+      folio = folios.data[0] ?? null;
+    } catch {
+    }
+    return { booking, folio };
+  }
+};
+function toDateString2(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
 // src/services/supply.ts
 var SupplyService = class extends BaseService {
   constructor() {
@@ -2488,6 +3318,169 @@ var SupplyService = class extends BaseService {
   }
 };
 
+// src/services/tables.ts
+var TablesHelper = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Reserve a table in a single call.
+   *
+   * Orchestrates three steps:
+   * 1. `client.availability.getTableSlots()` — verify available slots for the date
+   * 2. `client.guests.create()` — create the guest if inline data was provided
+   * 3. `client.bookings.create()` — create and auto-confirm the booking
+   *
+   * @throws {Error} if no table slots are available for the requested date
+   */
+  async reserve(input) {
+    const slots = await this.client.availability.getTableSlots({
+      propertyId: input.propertyId,
+      date: input.date,
+      guests: input.guests,
+      categoryId: input.categoryId,
+      duration: input.duration ?? 90
+    });
+    if (slots.length === 0) {
+      throw new Error("No table slots available");
+    }
+    const guestId = typeof input.guest === "string" ? input.guest : (await this.client.guests.create(input.guest)).id;
+    const duration = input.duration ?? 90;
+    const checkIn = toISODateTime2(input.date, input.time);
+    const checkOut = toISODateTime2(input.date, addMinutes2(input.time, duration));
+    const booking = await this.client.bookings.create({
+      propertyId: input.propertyId,
+      categoryId: input.categoryId ?? "default",
+      guestId,
+      checkIn,
+      checkOut,
+      type: "table",
+      guests: input.guests,
+      spaceId: input.spaceId,
+      notes: input.notes,
+      autoConfirm: true
+    });
+    return { booking, guestId };
+  }
+  /**
+   * Get available table time slots for a specific date.
+   *
+   * Delegates to `client.availability.getTableSlots()`.
+   */
+  async getSlots(params) {
+    return this.client.availability.getTableSlots(params);
+  }
+  /**
+   * Build a floor plan showing every table and its current reservation status.
+   *
+   * Calls `client.spaces.list()` to retrieve all table spaces, then
+   * `client.bookings.list()` to retrieve active bookings for the date,
+   * and maps each space to a `FloorPlanTable` with its computed status.
+   *
+   * Status rules:
+   * - `occupied` — booking with status `checked_in`
+   * - `reserved` — booking with status `confirmed`
+   * - `available` — no active booking found for the space
+   */
+  async getFloorPlan(params) {
+    const spacesResult = await this.client.spaces.list({
+      propertyId: params.propertyId,
+      type: "table"
+    });
+    const date = params.date ?? toDateString3(/* @__PURE__ */ new Date());
+    const bookingsResult = await this.client.bookings.list({
+      propertyId: params.propertyId,
+      type: "table",
+      status: ["confirmed", "checked_in"],
+      checkInFrom: date,
+      checkInTo: date
+    });
+    const bookingBySpace = /* @__PURE__ */ new Map();
+    for (const bk of bookingsResult.data) {
+      if (bk.spaceId) {
+        bookingBySpace.set(bk.spaceId, bk.id);
+      }
+    }
+    return spacesResult.data.map((space) => {
+      const bookingId = bookingBySpace.get(space.id) ?? null;
+      let status = "available";
+      if (bookingId) {
+        const bk = bookingsResult.data.find((b) => b.id === bookingId);
+        status = bk?.status === "checked_in" ? "occupied" : "reserved";
+      }
+      return {
+        spaceId: space.id,
+        name: space.name,
+        capacity: space.capacity ?? 0,
+        floor: space.floor ?? null,
+        status,
+        bookingId
+      };
+    });
+  }
+  /**
+   * Get all waitlist bookings for a property, ordered FIFO (oldest first).
+   *
+   * Calls `client.bookings.list()` filtered by `status: "waitlist"` and
+   * `type: "table"`, sorted by `createdAt` ascending.
+   */
+  async getWaitlist(propertyId) {
+    const result = await this.client.bookings.list({
+      propertyId,
+      status: "waitlist",
+      type: "table",
+      sort: { field: "createdAt", direction: "asc" }
+    });
+    return result.data;
+  }
+  /**
+   * Add a guest to the waitlist for a date and time.
+   *
+   * Resolves or creates the guest via `client.guests.create()` if inline data
+   * is provided, then creates a booking via `client.bookings.create()` with
+   * `metadata.waitlist: true`. The booking starts in `pending` status.
+   */
+  async addToWaitlist(input) {
+    const guestId = typeof input.guest === "string" ? input.guest : (await this.client.guests.create(input.guest)).id;
+    const checkIn = toISODateTime2(input.date, input.time);
+    return this.client.bookings.create({
+      propertyId: input.propertyId,
+      categoryId: "default",
+      guestId,
+      checkIn,
+      checkOut: checkIn,
+      type: "table",
+      guests: input.guests,
+      notes: input.notes,
+      metadata: { waitlist: true }
+    });
+  }
+  /**
+   * Remove a booking from the waitlist.
+   *
+   * Calls `client.bookings.delete()` on the given booking ID.
+   */
+  async removeFromWaitlist(bookingId) {
+    await this.client.bookings.delete(bookingId);
+  }
+};
+function toDateString3(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function toISODateTime2(date, time) {
+  return `${date}T${time}:00.000Z`;
+}
+function addMinutes2(time, mins) {
+  const [hourStr, minuteStr] = time.split(":");
+  const totalMinutes = Number(hourStr) * 60 + Number(minuteStr) + mins;
+  const h = Math.floor(totalMinutes / 60) % 24;
+  const m = totalMinutes % 60;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+}
+
 // src/services/tasks.ts
 var TasksService = class extends BaseService {
   constructor() {
@@ -2519,10 +3512,338 @@ var TasksService = class extends BaseService {
   }
 };
 
+// src/services/webhooks.ts
+var WebhooksService = class extends BaseService {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/webhooks/v1";
+  }
+  /** Create a new webhook subscription */
+  createSubscription(input) {
+    return this._post(this._buildPath("subscriptions"), input);
+  }
+  /** List webhook subscriptions with optional filters */
+  listSubscriptions(params) {
+    if (!params) {
+      return this._get(this._buildPath("subscriptions"));
+    }
+    const query = {};
+    if (params.active !== void 0) query.active = params.active;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("subscriptions"), query);
+  }
+  /** Update a webhook subscription */
+  updateSubscription(subscriptionId, input) {
+    return this._patch(
+      this._buildPath("subscriptions", subscriptionId),
+      input
+    );
+  }
+  /** List webhook delivery attempts with optional filters */
+  listDeliveries(params) {
+    if (!params) {
+      return this._get(this._buildPath("deliveries"));
+    }
+    const query = {};
+    if (params.subscriptionId !== void 0) query.subscriptionId = params.subscriptionId;
+    if (params.status !== void 0) query.status = params.status;
+    if (params.from !== void 0) query.from = params.from;
+    if (params.to !== void 0) query.to = params.to;
+    if (params.limit !== void 0) query.limit = params.limit;
+    if (params.cursor !== void 0) query.cursor = params.cursor;
+    return this._get(this._buildPath("deliveries"), query);
+  }
+};
+
+// src/sse.ts
+var SSEClient = class {
+  /**
+   * Create a new `SSEClient`.
+   *
+   * @param baseUrl - Base URL of the booking platform API (e.g., `"https://api.atzentis.io"`).
+   * @param apiKey - API key used to authenticate the SSE stream request.
+   * @param config - Optional client configuration for reconnect behaviour and custom `EventSource`.
+   */
+  constructor(baseUrl, apiKey, config) {
+    // Connection state
+    this.eventSource = null;
+    this._state = "disconnected";
+    this._connectedAt = null;
+    this._lastEventAt = null;
+    this._lastEventId = null;
+    // Reconnect state
+    this._reconnectAttempts = 0;
+    this._reconnectTimer = null;
+    this._isDisconnecting = false;
+    /**
+     * Internal handler registry.
+     *
+     * Keys are event type strings (including wildcards). The value type is
+     * intentionally `SSEEventHandler<any>` here because the Map must hold
+     * handlers for many different event types — the public API enforces correct
+     * typing through the overloaded `on()` and `off()` signatures.
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: registry holds mixed handler types
+    this.handlers = /* @__PURE__ */ new Map();
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.config = {
+      initialReconnectDelay: config?.initialReconnectDelay ?? 1e3,
+      maxReconnectDelay: config?.maxReconnectDelay ?? 3e4,
+      maxReconnectAttempts: config?.maxReconnectAttempts ?? Number.POSITIVE_INFINITY
+    };
+    this.EventSourceImpl = config?.EventSource ?? globalThis.EventSource;
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  /**
+   * Open the SSE connection to the platform stream.
+   *
+   * If a connection is already active it is closed and a new one is opened
+   * with the supplied options. The `lastEventId` tracking from a previous
+   * session is preserved for automatic replay unless explicitly overridden in
+   * `options.lastEventId`.
+   *
+   * @param options - Optional filters for channels, property, and replay cursor.
+   */
+  connect(options) {
+    if (this.eventSource) {
+      this._closeEventSource();
+    }
+    this._isDisconnecting = false;
+    this._connectOptions = options;
+    this._state = "connecting";
+    const url = this._buildUrl(options);
+    this.eventSource = new this.EventSourceImpl(url);
+    this.eventSource.onopen = () => {
+      this._state = "connected";
+      this._connectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this._reconnectAttempts = 0;
+      this._emit("connection.opened", {
+        type: "connection.opened",
+        id: this._generateId("conn"),
+        timestamp: this._connectedAt,
+        propertyId: options?.propertyId ?? "",
+        data: { connectedAt: this._connectedAt }
+      });
+    };
+    this.eventSource.onerror = () => {
+      if (this._isDisconnecting) return;
+      this._emit("connection.error", {
+        type: "connection.error",
+        id: this._generateId("err"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        propertyId: this._connectOptions?.propertyId ?? "",
+        data: { error: "Connection lost", recoverable: true }
+      });
+      this._scheduleReconnect();
+    };
+    this.eventSource.onmessage = (event) => {
+      this._handleMessage(event);
+    };
+  }
+  /**
+   * Close the SSE connection and cancel any pending reconnect timer.
+   *
+   * Emits a `connection.closed` lifecycle event with `wasClean: true` if the
+   * client was connected or connecting at the time of the call.
+   */
+  disconnect() {
+    this._isDisconnecting = true;
+    this._clearReconnectTimer();
+    this._closeEventSource();
+    const wasConnected = this._state !== "disconnected";
+    this._state = "disconnected";
+    this._reconnectAttempts = 0;
+    if (wasConnected) {
+      this._emit("connection.closed", {
+        type: "connection.closed",
+        id: this._generateId("close"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        propertyId: this._connectOptions?.propertyId ?? "",
+        data: { reason: "Client disconnected", wasClean: true }
+      });
+    }
+  }
+  on(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(eventType)?.add(handler);
+  }
+  off(eventType, handler) {
+    const set = this.handlers.get(eventType);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) this.handlers.delete(eventType);
+    }
+  }
+  /**
+   * Return a snapshot of the current connection status.
+   *
+   * This is a pure read — calling it has no side effects.
+   */
+  getStatus() {
+    return {
+      state: this._state,
+      reconnectAttempts: this._reconnectAttempts,
+      connectedAt: this._connectedAt,
+      lastEventAt: this._lastEventAt,
+      lastEventId: this._lastEventId
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Internal methods
+  // -------------------------------------------------------------------------
+  /**
+   * Build the full SSE stream URL including query parameters.
+   *
+   * The API key is always appended. Optional filters for channels, property ID,
+   * and last-event-id for replay are appended when present.
+   */
+  _buildUrl(options) {
+    const url = new URL("/sse/v1/stream", this.baseUrl);
+    url.searchParams.set("apiKey", this.apiKey);
+    if (options?.channels && options.channels.length > 0) {
+      url.searchParams.set("channels", options.channels.join(","));
+    }
+    if (options?.propertyId) {
+      url.searchParams.set("propertyId", options.propertyId);
+    }
+    const lastEventId = options?.lastEventId ?? this._lastEventId;
+    if (lastEventId) {
+      url.searchParams.set("lastEventId", lastEventId);
+    }
+    return url.toString();
+  }
+  /**
+   * Parse and dispatch an incoming `MessageEvent` from the `EventSource`.
+   *
+   * Malformed JSON is silently ignored to keep the connection stable.
+   */
+  _handleMessage(event) {
+    try {
+      const parsed = JSON.parse(event.data);
+      this._lastEventAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (parsed.id) this._lastEventId = parsed.id;
+      this._emit(parsed.type, parsed);
+    } catch {
+    }
+  }
+  /**
+   * Dispatch an event to all matching handlers in the registry.
+   *
+   * Dispatch order:
+   * 1. Handlers registered for the exact event type string.
+   * 2. Handlers registered for the channel wildcard (e.g., `"booking.*"`).
+   * 3. Handlers registered for the global wildcard (`"*"`).
+   */
+  _emit(eventType, event) {
+    const specific = this.handlers.get(eventType);
+    if (specific) {
+      for (const handler of specific) handler(event);
+    }
+    const channel = eventType.split(".")[0];
+    const channelWildcard = this.handlers.get(`${channel}.*`);
+    if (channelWildcard && eventType !== `${channel}.*`) {
+      for (const handler of channelWildcard) handler(event);
+    }
+    const global = this.handlers.get("*");
+    if (global && eventType !== "*") {
+      for (const handler of global) handler(event);
+    }
+  }
+  /**
+   * Schedule a reconnect attempt using exponential backoff with jitter.
+   *
+   * Closes the current `EventSource`, increments the attempt counter, emits
+   * a `connection.reconnecting` lifecycle event, then calls `connect()` after
+   * the computed delay.
+   *
+   * If `maxReconnectAttempts` is exceeded the client enters `disconnected`
+   * state and emits a final `connection.closed` lifecycle event.
+   */
+  _scheduleReconnect() {
+    this._closeEventSource();
+    if (this._isDisconnecting) return;
+    if (this._reconnectAttempts >= this.config.maxReconnectAttempts) {
+      this._state = "disconnected";
+      this._emit("connection.closed", {
+        type: "connection.closed",
+        id: this._generateId("close"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        propertyId: this._connectOptions?.propertyId ?? "",
+        data: { reason: "Max reconnect attempts exceeded", wasClean: false }
+      });
+      return;
+    }
+    this._state = "reconnecting";
+    this._reconnectAttempts++;
+    const base = Math.min(
+      this.config.initialReconnectDelay * 2 ** (this._reconnectAttempts - 1),
+      this.config.maxReconnectDelay
+    );
+    const delay = base + Math.random() * 1e3;
+    this._emit("connection.reconnecting", {
+      type: "connection.reconnecting",
+      id: this._generateId("reconn"),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      propertyId: this._connectOptions?.propertyId ?? "",
+      data: { attempt: this._reconnectAttempts, delay: Math.round(delay) }
+    });
+    this._reconnectTimer = setTimeout(() => {
+      if (!this._isDisconnecting) {
+        this.connect(this._connectOptions);
+      }
+    }, delay);
+  }
+  /**
+   * Detach all event listeners and close the underlying `EventSource`.
+   *
+   * Listeners are removed before calling `close()` to prevent the `onerror`
+   * callback from firing during a deliberate teardown.
+   */
+  _closeEventSource() {
+    if (this.eventSource) {
+      this.eventSource.onopen = null;
+      this.eventSource.onerror = null;
+      this.eventSource.onmessage = null;
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+  /**
+   * Cancel the pending reconnect timer if one is scheduled.
+   */
+  _clearReconnectTimer() {
+    if (this._reconnectTimer !== null) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+  }
+  /**
+   * Generate a lightweight unique ID for synthetic lifecycle events.
+   *
+   * Uses `crypto.randomUUID()` when available (browsers, Node 19+, Bun).
+   * Falls back to a timestamp-based string in older environments.
+   *
+   * @param prefix - Short label for readability (e.g., `"conn"`, `"err"`).
+   */
+  _generateId(prefix) {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  }
+};
+
 // src/client.ts
 var BookingClient = class {
   constructor(config) {
     const validated = bookingClientConfigSchema.parse(config);
+    this._config = validated;
     this.httpClient = new HttpClient({
       baseUrl: validated.baseUrl,
       apiKey: validated.apiKey,
@@ -2546,6 +3867,11 @@ var BookingClient = class {
     this._bookings ?? (this._bookings = new BookingsService(this.httpClient));
     return this._bookings;
   }
+  /** Concierge service — lazy-initialized on first access */
+  get concierge() {
+    this._concierge ?? (this._concierge = new ConciergeService(this.httpClient));
+    return this._concierge;
+  }
   /** Distribution service — lazy-initialized on first access */
   get distribution() {
     this._distribution ?? (this._distribution = new DistributionService(this.httpClient));
@@ -2556,6 +3882,11 @@ var BookingClient = class {
     this._finance ?? (this._finance = new FinanceService(this.httpClient));
     return this._finance;
   }
+  /** Fiscal service — lazy-initialized on first access */
+  get fiscal() {
+    this._fiscal ?? (this._fiscal = new FiscalService(this.httpClient));
+    return this._fiscal;
+  }
   /** Groups service — lazy-initialized on first access */
   get groups() {
     this._groups ?? (this._groups = new GroupsService(this.httpClient));
@@ -2571,16 +3902,36 @@ var BookingClient = class {
     this._housekeeping ?? (this._housekeeping = new HousekeepingService(this.httpClient));
     return this._housekeeping;
   }
+  /** ID scanning service — lazy-initialized on first access */
+  get idScanning() {
+    this._idScanning ?? (this._idScanning = new IdScanningService(this.httpClient));
+    return this._idScanning;
+  }
+  /** Intelligence service — lazy-initialized on first access */
+  get intelligence() {
+    this._intelligence ?? (this._intelligence = new IntelligenceService(this.httpClient));
+    return this._intelligence;
+  }
   /** Night audit service — lazy-initialized on first access */
   get nightAudit() {
     this._nightAudit ?? (this._nightAudit = new NightAuditService(this.httpClient));
     return this._nightAudit;
   }
+  /** Notifications service — lazy-initialized on first access */
+  get notifications() {
+    this._notifications ?? (this._notifications = new NotificationsService(this.httpClient));
+    return this._notifications;
+  }
   /** Payments service — lazy-initialized on first access */
   get payments() {
     this._payments ?? (this._payments = new PaymentsService(this.httpClient));
     return this._payments;
   }
+  /** Portfolios service — lazy-initialized on first access */
+  get portfolios() {
+    this._portfolios ?? (this._portfolios = new PortfoliosService(this.httpClient));
+    return this._portfolios;
+  }
   /** Properties service — lazy-initialized on first access */
   get properties() {
     this._properties ?? (this._properties = new PropertiesService(this.httpClient));
@@ -2591,6 +3942,11 @@ var BookingClient = class {
     this._ratePlans ?? (this._ratePlans = new RatePlansService(this.httpClient));
     return this._ratePlans;
   }
+  /** Revenue service — lazy-initialized on first access */
+  get revenue() {
+    this._revenue ?? (this._revenue = new RevenueService(this.httpClient));
+    return this._revenue;
+  }
   /** Categories service — lazy-initialized on first access */
   get categories() {
     this._categories ?? (this._categories = new CategoriesService(this.httpClient));
@@ -2606,6 +3962,11 @@ var BookingClient = class {
     this._reviews ?? (this._reviews = new ReviewsService(this.httpClient));
     return this._reviews;
   }
+  /** Settings service — lazy-initialized on first access */
+  get settings() {
+    this._settings ?? (this._settings = new SettingsService(this.httpClient));
+    return this._settings;
+  }
   /** Spaces service — lazy-initialized on first access */
   get spaces() {
     this._spaces ?? (this._spaces = new SpacesService(this.httpClient));
@@ -2626,6 +3987,31 @@ var BookingClient = class {
     this._tasks ?? (this._tasks = new TasksService(this.httpClient));
     return this._tasks;
   }
+  /** Webhooks service — lazy-initialized on first access */
+  get webhooks() {
+    this._webhooks ?? (this._webhooks = new WebhooksService(this.httpClient));
+    return this._webhooks;
+  }
+  /** Stays vertical helper — lazy-initialized on first access */
+  get stays() {
+    this._stays ?? (this._stays = new StaysHelper(this));
+    return this._stays;
+  }
+  /** Tables vertical helper — lazy-initialized on first access */
+  get tables() {
+    this._tables ?? (this._tables = new TablesHelper(this));
+    return this._tables;
+  }
+  /** Services vertical helper — lazy-initialized on first access */
+  get services() {
+    this._services ?? (this._services = new ServicesHelper(this));
+    return this._services;
+  }
+  /** SSE client — lazy-initialized on first access */
+  get sse() {
+    this._sse ?? (this._sse = new SSEClient(this._config.baseUrl, this._config.apiKey));
+    return this._sse;
+  }
   setApiKey(key) {
     if (!key || key.trim().length === 0) {
       throw new Error("apiKey must be a non-empty string");
@@ -2742,35 +4128,48 @@ var VERSION = "0.1.0";
   BookingError,
   BookingsService,
   CategoriesService,
+  ConciergeService,
   ConflictError,
   DEFAULT_MODULES,
   DiscountsService,
   DistributionService,
   FinanceService,
+  FiscalService,
   ForbiddenError,
   GroupsService,
   GuestsService,
   HousekeepingService,
   HttpClient,
+  IdScanningService,
+  IntelligenceService,
   NightAuditService,
   NotFoundError,
+  NotificationsService,
   PROPERTY_MODULES,
   PaymentError,
   PaymentsService,
+  PortfoliosService,
   PropertiesService,
   RateLimitError,
   RatePlansService,
+  RevenueService,
   ReviewsService,
   SPACE_STATUSES,
   SPACE_TYPES,
+  SSEClient,
   ServerError,
+  ServicesHelper,
+  SettingsService,
   SpacesService,
   StaffService,
+  StaysHelper,
   SupplyService,
+  TablesHelper,
   TasksService,
   TimeoutError,
   VERSION,
   ValidationError,
+  WebhooksService,
   bookingClientConfigSchema,
   createErrorFromResponse,
   firstPage,