@slotchain/sdk 1.0.0

package/dist/index.cjs.js

@@ -0,0 +1,1463 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SlotlyApiError: () => SlotlyApiError,
+  SlotlyAuthError: () => SlotlyAuthError,
+  SlotlyConfigurationError: () => SlotlyConfigurationError,
+  SlotlyNetworkError: () => SlotlyNetworkError,
+  default: () => index_default,
+  getSlotlyContext: () => getSlotlyContext,
+  useSlotly: () => useSlotly,
+  validateSlotlyRequest: () => validateSlotlyRequest
+});
+module.exports = __toCommonJS(index_exports);
+var import_axios2 = __toESM(require("axios"));
+
+// src/clients/tenant-client.ts
+var TenantClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get tenant configuration by slug
+   * GET /api/v1/tenant-config/:slug
+   */
+  async getBySlug(slug) {
+    const response = await this.client.get(
+      `/api/v1/tenant-config/${slug}`
+    );
+    return response.data;
+  }
+  /**
+   * Get tenant by ID
+   * GET /api/v1/tenants/:id
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/tenants/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List all tenants
+   * GET /api/v1/tenants
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/tenants",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new tenant
+   * POST /api/v1/tenants
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/tenants",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update tenant by ID
+   * PATCH /api/v1/tenants/:id
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/api/v1/tenants/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete tenant by ID
+   * DELETE /api/v1/tenants/:id
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/tenants/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get full tenant configuration including branding, services, and service items
+   * GET /api/v1/tenants/:slug
+   * 
+   * This method returns the complete tenant configuration including:
+   * - Tenant basic info (id, slug, name)
+   * - Branding configuration (logo, colors, etc.)
+   * - All services associated with the tenant (with nested service items)
+   * - Feature flags and subscription level
+   * 
+   * Note: Service items are nested within each service object (not as a separate top-level array).
+   * The endpoint returns full config by default (includes services with nested items).
+   * 
+   * @param slug - Tenant slug identifier (required, non-nullable)
+   * @param includeServices - Include services with nested items (default: true)
+   * @returns Promise resolving to ApiResponse<TenantFullConfig>
+   * 
+   * @example
+   * ```typescript
+   * const result = await slotly.tenant.getFullConfig('bright-accountants');
+   * if (result.success && result.data) {
+   *   const config = result.data;
+   *   console.log('Tenant:', config.name);
+   *   console.log('Logo:', config.branding?.logoUrl);
+   *   console.log('Services:', config.services.length);
+   *   
+   *   // Service items are nested within each service
+   *   config.services.forEach(service => {
+   *     console.log(`Service: ${service.name}`);
+   *     if (service.serviceItems) {
+   *       console.log(`  Items: ${service.serviceItems.length}`);
+   *     }
+   *   });
+   * }
+   * ```
+   * 
+   * **Guaranteed fields (non-nullable):**
+   * - `id`: string
+   * - `slug`: string
+   * - `name`: string
+   * - `services`: ServiceWithItems[] (may be empty array, each service may have nested `serviceItems`)
+   * 
+   * **Optional fields:**
+   * - `branding`: TenantBranding | undefined
+   * - `services[].serviceItems`: ServiceItem[] | undefined (nested within each service)
+   * - `featuresEnabled`: string[] | undefined
+   * - `subscriptionLevel`: string | undefined
+   * - `config`: Record<string, any> | undefined
+   * 
+   * **Error Codes:**
+   * - `TENANT_NOT_FOUND` - Tenant with slug not found
+   * - `AUTH_ERROR` - Authentication failed
+   * - `PERMISSION_DENIED` - Insufficient permissions
+   * - `NETWORK_ERROR` - Network request failed
+   */
+  async getFullConfig(slug, includeServices = true) {
+    const response = await this.client.get(
+      `/api/v1/tenants/${slug}`,
+      { params: { includeServices } }
+    );
+    return response.data;
+  }
+};
+
+// src/clients/booking-client.ts
+var BookingClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get booking by ID
+   * GET /api/v1/bookings/:id
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/bookings/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List bookings
+   * GET /api/v1/bookings
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/bookings",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new booking (publishes booking.created event)
+   * POST /api/v1/bookings
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/bookings",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update booking by ID
+   * PUT /api/v1/bookings/:id
+   */
+  async update(id, data) {
+    const response = await this.client.put(
+      `/api/v1/bookings/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Cancel booking by ID
+   * Note: Cancel is typically done via update with status change
+   * If dedicated cancel endpoint exists, update this method
+   */
+  async cancel(id) {
+    return this.update(id, { status: "cancelled" });
+  }
+  /**
+   * Delete booking by ID (soft delete)
+   * DELETE /api/v1/bookings/:id
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/bookings/${id}`
+    );
+    return response.data;
+  }
+};
+
+// src/clients/service-client.ts
+var ServiceClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get service by ID
+   * GET /api/v1/services/:id
+   * 
+   * @param id - Service ID
+   * @param includeItems - Include nested service items (default: false)
+   * @returns Service details (with items if includeItems=true)
+   */
+  async getById(id, includeItems = false) {
+    const response = await this.client.get(
+      `/api/v1/services/${id}`,
+      includeItems ? { params: { includeItems: true } } : void 0
+    );
+    return response.data;
+  }
+  /**
+   * List services by tenant slug
+   * GET /api/v1/services?tenantSlug=:slug
+   * 
+   * @param slug - Tenant slug (or use tenant_id in list() method)
+   * @param params - Optional parameters (includeItems, page, limit, is_active)
+   * @returns List of services for the tenant
+   */
+  async listServices(slug, params) {
+    const response = await this.client.get(
+      "/api/v1/services",
+      { params: { tenantSlug: slug, ...params } }
+    );
+    return response.data;
+  }
+  /**
+   * List services with optional filters
+   * GET /api/v1/services
+   * 
+   * @param params - Query parameters (tenant_id, tenantSlug, slot_id, page, limit, is_active, includeItems)
+   * @returns Paginated list of services
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/services",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new service
+   * POST /api/v1/services
+   * 
+   * @param data - Service creation data (tenant_id, name required)
+   * @returns Created service
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/services",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update service by ID
+   * PUT /api/v1/services/:id
+   * 
+   * @param id - Service ID
+   * @param data - Service update data
+   * @returns Updated service
+   */
+  async update(id, data) {
+    const response = await this.client.put(
+      `/api/v1/services/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete service by ID
+   * DELETE /api/v1/services/:id
+   * 
+   * @param id - Service ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/services/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Bulk create services
+   * POST /api/v1/services/bulk (if available)
+   * 
+   * @param services - Array of services to create
+   * @returns Created services
+   */
+  async bulkCreate(services) {
+    const response = await this.client.post(
+      "/api/v1/services/bulk",
+      { services }
+    );
+    return response.data;
+  }
+  /**
+   * Get service with its service items nested
+   * GET /api/v1/services/:id?includeItems=true
+   * 
+   * @param id - Service ID
+   * @returns Service with nested service items
+   */
+  async getWithItems(id) {
+    const response = await this.client.get(
+      `/api/v1/services/${id}`,
+      { params: { includeItems: true } }
+    );
+    return response.data;
+  }
+  /**
+   * List services with their service items nested
+   * GET /api/v1/services?includeItems=true
+   * 
+   * @param params - Query parameters (tenant_id, tenantSlug, slot_id, page, limit, is_active)
+   * @returns Paginated list of services with nested service items
+   */
+  async listWithItems(params) {
+    const response = await this.client.get(
+      "/api/v1/services",
+      { params: { includeItems: true, ...params } }
+    );
+    return response.data;
+  }
+  /**
+   * List all categories for a tenant (extracted from services)
+   * GET /api/v1/categories?tenantSlug=:slug
+   * 
+   * @param tenantSlug - Tenant slug (or use tenant_id in params)
+   * @param params - Optional query parameters (tenant_id, includeServices)
+   * @returns List of categories for the tenant
+   */
+  async listCategories(tenantSlug, params) {
+    const response = await this.client.get(
+      "/api/v1/categories",
+      { params: { tenantSlug, ...params } }
+    );
+    return response.data;
+  }
+  /**
+   * Get category by ID (category name, lowercase)
+   * GET /api/v1/categories/:id?tenantSlug=:slug
+   * 
+   * @param categoryId - Category ID (lowercase category name, e.g., "consulting")
+   * @param tenantSlug - Tenant slug (or use tenant_id in params)
+   * @param params - Optional query parameters (tenant_id, includeServices, includeItems)
+   * @returns Category details
+   */
+  async getCategory(categoryId, tenantSlug, params) {
+    const response = await this.client.get(
+      `/api/v1/categories/${categoryId}`,
+      { params: { tenantSlug, ...params } }
+    );
+    return response.data;
+  }
+};
+
+// src/clients/service-item-client.ts
+var ServiceItemClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get service item by ID
+   * GET /api/v1/service-items/:id
+   * 
+   * @param id - Service item ID
+   * @returns Service item details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/service-items/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List all service items for a service
+   * GET /api/v1/services/:serviceId/items
+   * 
+   * @param serviceId - Service ID
+   * @returns List of service items for the specified service
+   */
+  async listByService(serviceId) {
+    const response = await this.client.get(
+      `/api/v1/services/${serviceId}/items`
+    );
+    return response.data;
+  }
+  /**
+   * Create a new service item for a service
+   * POST /api/v1/services/:serviceId/items
+   * 
+   * @param serviceId - Service ID
+   * @param data - Service item creation data
+   * @returns Created service item
+   */
+  async createForService(serviceId, data) {
+    const response = await this.client.post(
+      `/api/v1/services/${serviceId}/items`,
+      { ...data, service_id: serviceId }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new service item
+   * POST /api/v1/service-items (alternative to createForService)
+   * 
+   * @param data - Service item creation data (must include service_id)
+   * @returns Created service item
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/service-items",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update service item by ID
+   * PUT /api/v1/service-items/:id
+   * 
+   * @param id - Service item ID
+   * @param data - Service item update data
+   * @returns Updated service item
+   */
+  async update(id, data) {
+    const response = await this.client.put(
+      `/api/v1/service-items/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete service item by ID
+   * DELETE /api/v1/service-items/:id
+   * 
+   * @param id - Service item ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/service-items/${id}`
+    );
+    return response.data;
+  }
+};
+
+// src/clients/slot-client.ts
+var SlotClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get slot by ID
+   * GET /api/v1/slots/:id
+   * 
+   * @param id - Slot ID
+   * @returns Slot details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/slots/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List available slots
+   * GET /api/v1/slots
+   * 
+   * @param params - Query parameters (tenant_id required, status, is_active, page, limit)
+   * @returns Paginated list of slots
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/slots",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new slot
+   * POST /api/v1/slots
+   * 
+   * @param data - Slot creation data (tenant_id, name required)
+   * @returns Created slot
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/slots",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update slot by ID
+   * PUT /api/v1/slots/:id
+   * 
+   * @param id - Slot ID
+   * @param data - Slot update data
+   * @returns Updated slot
+   */
+  async update(id, data) {
+    const response = await this.client.put(
+      `/api/v1/slots/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete slot by ID
+   * DELETE /api/v1/slots/:id
+   * 
+   * @param id - Slot ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/slots/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Bulk create slots
+   * POST /api/v1/slots/bulk (verify if available)
+   * 
+   * @param slots - Array of slots to create
+   * @returns Created slots
+   */
+  async bulkCreate(slots) {
+    const response = await this.client.post(
+      "/api/v1/slots/bulk",
+      { slots }
+    );
+    return response.data;
+  }
+  /**
+   * Mark slot as available/unavailable
+   * Note: Use update() method with status or other fields
+   */
+  async setAvailability(id, available) {
+    return this.update(id, { status: available ? "active" : "inactive" });
+  }
+  /**
+   * Get all active services for a slot with their items
+   * GET /api/v1/slots/:id/services
+   * 
+   * @param id - Slot ID
+   * @returns Services with nested service items
+   */
+  async getServices(id) {
+    const response = await this.client.get(
+      `/api/v1/slots/${id}/services`
+    );
+    return response.data;
+  }
+  /**
+   * Get slot with tenant information
+   * GET /api/v1/slots/:id/tenant-info
+   * 
+   * @param id - Slot ID
+   * @returns Slot with tenant data
+   */
+  async getWithTenant(id) {
+    const response = await this.client.get(
+      `/api/v1/slots/${id}/tenant-info`
+    );
+    return response.data;
+  }
+};
+
+// src/clients/customer-client.ts
+var CustomerClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get customer by ID
+   * GET /api/v1/customers/:id
+   * 
+   * @param id - Customer ID
+   * @returns Customer details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/customers/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get customer by email
+   * GET /api/v1/customers?email=:email&tenant_id=:id
+   * 
+   * @param email - Customer email
+   * @param tenantId - Required tenant ID for scoping
+   * @returns Customer details
+   */
+  async getByEmail(email, tenantId) {
+    const response = await this.client.get(
+      "/api/v1/customers",
+      { params: { email, tenant_id: tenantId } }
+    );
+    return response.data;
+  }
+  /**
+   * List customers with optional filters
+   * GET /api/v1/customers
+   * 
+   * @param params - Query parameters (tenant_id required, page, limit, search, is_guest)
+   * @returns Paginated list of customers
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/customers",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new customer
+   * POST /api/v1/customers
+   * 
+   * @param data - Customer creation data (tenant_id, name, email required)
+   * @returns Created customer
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/customers",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update customer by ID
+   * PUT /api/v1/customers/:id
+   * 
+   * @param id - Customer ID
+   * @param data - Customer update data
+   * @returns Updated customer
+   */
+  async update(id, data) {
+    const response = await this.client.put(
+      `/api/v1/customers/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete customer by ID
+   * DELETE /api/v1/customers/:id
+   * 
+   * @param id - Customer ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/customers/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Lookup customer by userId or tenantId
+   * GET /api/v1/customers/lookup
+   * 
+   * @param params - Query parameters (userId optional, tenantId required)
+   * @returns Customer or null
+   */
+  async lookup(params) {
+    const response = await this.client.get(
+      "/api/v1/customers/lookup",
+      { params: { userId: params.userId, tenantId: params.tenantId } }
+    );
+    return response.data;
+  }
+  /**
+   * Get autocomplete data from existing customers and bookings
+   * GET /api/v1/customers/autocomplete
+   * 
+   * @param tenantId - Tenant ID (required)
+   * @returns Autocomplete data
+   */
+  async autocomplete(tenantId) {
+    const response = await this.client.get(
+      "/api/v1/customers/autocomplete",
+      { params: { tenantId } }
+    );
+    return response.data;
+  }
+  /**
+   * Get all bookings for a customer
+   * GET /api/v1/customers/bookings
+   * 
+   * @param params - Query parameters (email optional, userId optional, tenantId required)
+   * @returns Customer bookings data
+   */
+  async getBookings(params) {
+    const response = await this.client.get(
+      "/api/v1/customers/bookings",
+      { params }
+    );
+    return response.data;
+  }
+};
+
+// src/clients/flow-client.ts
+var FlowClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get flow by ID
+   * GET /api/v1/flows/:id
+   * 
+   * @param id - Flow ID
+   * @returns Flow details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/flows/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List flows with optional filters
+   * GET /api/v1/flows
+   * 
+   * @param params - Query parameters (tenantId, page, limit)
+   * @returns Paginated list of flows
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/flows",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new flow
+   * POST /api/v1/flows
+   * 
+   * @param data - Flow creation data
+   * @returns Created flow
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/flows",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update flow by ID
+   * PATCH /api/v1/flows/:id
+   * 
+   * @param id - Flow ID
+   * @param data - Flow update data
+   * @returns Updated flow
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/api/v1/flows/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete flow by ID
+   * DELETE /api/v1/flows/:id
+   * 
+   * @param id - Flow ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/flows/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Execute a flow
+   * POST /api/v1/flows/:id/execute
+   * 
+   * @param id - Flow ID
+   * @param input - Optional input data for flow execution
+   * @returns Flow execution result
+   */
+  async execute(id, input) {
+    const response = await this.client.post(
+      `/api/v1/flows/${id}/execute`,
+      { input }
+    );
+    return response.data;
+  }
+};
+
+// src/clients/studio-client.ts
+var StudioClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get studio by ID
+   * GET /api/v1/studios/:id
+   * 
+   * @param id - Studio ID
+   * @returns Studio details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/studios/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get studio by slug
+   * GET /api/v1/studios/slug/:slug
+   * 
+   * @param slug - Studio slug
+   * @returns Studio details
+   */
+  async getBySlug(slug) {
+    const response = await this.client.get(
+      `/api/v1/studios/slug/${slug}`
+    );
+    return response.data;
+  }
+  /**
+   * List studios with optional filters
+   * GET /api/v1/studios
+   * 
+   * @param params - Query parameters (page, limit, search)
+   * @returns Paginated list of studios
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/studios",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new studio
+   * POST /api/v1/studios
+   * 
+   * @param data - Studio creation data
+   * @returns Created studio
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/studios",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update studio by ID
+   * PATCH /api/v1/studios/:id
+   * 
+   * @param id - Studio ID
+   * @param data - Studio update data
+   * @returns Updated studio
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/api/v1/studios/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete studio by ID
+   * DELETE /api/v1/studios/:id
+   * 
+   * @param id - Studio ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/studios/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * Get data quality issues for a studio
+   * GET /api/v1/studios/:id/data-quality
+   * 
+   * @param id - Studio ID
+   * @param params - Query parameters (resolved, severity)
+   * @returns List of data quality issues
+   */
+  async getDataQualityIssues(id, params) {
+    const response = await this.client.get(
+      `/api/v1/studios/${id}/data-quality`,
+      { params }
+    );
+    return response.data;
+  }
+};
+
+// src/clients/notification-client.ts
+var NotificationClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get notification by ID
+   * GET /api/v1/notifications/:id
+   * 
+   * @param id - Notification ID
+   * @returns Notification details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/notifications/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List notifications with optional filters
+   * GET /api/v1/notifications
+   * 
+   * @param params - Query parameters (tenantId, type, recipient, page, limit)
+   * @returns Paginated list of notifications
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/notifications",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Create a new notification
+   * POST /api/v1/notifications
+   * 
+   * @param data - Notification creation data
+   * @returns Created notification
+   */
+  async create(data) {
+    const response = await this.client.post(
+      "/api/v1/notifications",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Send notification immediately
+   * POST /api/v1/notifications/send
+   * 
+   * @param data - Notification data to send
+   * @returns Sent notification
+   */
+  async send(data) {
+    const response = await this.client.post(
+      "/api/v1/notifications/send",
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Update notification by ID
+   * PATCH /api/v1/notifications/:id
+   * 
+   * @param id - Notification ID
+   * @param data - Notification update data
+   * @returns Updated notification
+   */
+  async update(id, data) {
+    const response = await this.client.patch(
+      `/api/v1/notifications/${id}`,
+      data
+    );
+    return response.data;
+  }
+  /**
+   * Delete notification by ID
+   * DELETE /api/v1/notifications/:id
+   * 
+   * @param id - Notification ID
+   * @returns Empty response on success
+   */
+  async delete(id) {
+    const response = await this.client.delete(
+      `/api/v1/notifications/${id}`
+    );
+    return response.data;
+  }
+};
+
+// src/clients/data-quality-client.ts
+var DataQualityClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get data quality issue by ID
+   * GET /api/v1/data-quality/:id
+   * 
+   * @param id - Issue ID
+   * @returns Data quality issue details
+   */
+  async getById(id) {
+    const response = await this.client.get(
+      `/api/v1/data-quality/${id}`
+    );
+    return response.data;
+  }
+  /**
+   * List data quality issues with optional filters
+   * GET /api/v1/data-quality
+   * 
+   * @param params - Query parameters (tenantId, type, severity, resolved, page, limit)
+   * @returns Paginated list of data quality issues
+   */
+  async list(params) {
+    const response = await this.client.get(
+      "/api/v1/data-quality",
+      { params }
+    );
+    return response.data;
+  }
+  /**
+   * Run data quality check for a tenant
+   * POST /api/v1/data-quality/check
+   * 
+   * @param tenantId - Tenant ID to check
+   * @returns List of detected issues
+   */
+  async runCheck(tenantId) {
+    const response = await this.client.post(
+      "/api/v1/data-quality/check",
+      { tenantId }
+    );
+    return response.data;
+  }
+  /**
+   * Resolve a data quality issue
+   * PATCH /api/v1/data-quality/:id/resolve
+   * 
+   * @param id - Issue ID
+   * @returns Resolved issue
+   */
+  async resolve(id) {
+    const response = await this.client.patch(
+      `/api/v1/data-quality/${id}/resolve`,
+      { resolved: true }
+    );
+    return response.data;
+  }
+  /**
+   * Get data quality summary for a tenant
+   * GET /api/v1/data-quality/summary?tenantId=:id
+   * 
+   * @param tenantId - Tenant ID
+   * @returns Summary of data quality issues
+   */
+  async getSummary(tenantId) {
+    const response = await this.client.get(
+      "/api/v1/data-quality/summary",
+      { params: { tenantId } }
+    );
+    return response.data;
+  }
+};
+
+// src/errors.ts
+var SlotlyApiError = class _SlotlyApiError extends Error {
+  constructor(code, message, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "SlotlyApiError";
+    Object.setPrototypeOf(this, _SlotlyApiError.prototype);
+  }
+};
+var SlotlyAuthError = class _SlotlyAuthError extends SlotlyApiError {
+  constructor(message, details) {
+    super("AUTH_ERROR", message, 401, details);
+    this.name = "SlotlyAuthError";
+    Object.setPrototypeOf(this, _SlotlyAuthError.prototype);
+  }
+};
+var SlotlyNetworkError = class _SlotlyNetworkError extends Error {
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "SlotlyNetworkError";
+    Object.setPrototypeOf(this, _SlotlyNetworkError.prototype);
+  }
+};
+var SlotlyConfigurationError = class _SlotlyConfigurationError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "SlotlyConfigurationError";
+    Object.setPrototypeOf(this, _SlotlyConfigurationError.prototype);
+  }
+};
+
+// src/interceptors.ts
+function setupRequestInterceptor() {
+  return (config) => {
+    return config;
+  };
+}
+function setupResponseInterceptor() {
+  return (response) => {
+    return response;
+  };
+}
+function setupErrorInterceptor() {
+  return (error) => {
+    if (!error.response) {
+      const networkError = new SlotlyNetworkError(
+        error.message || "Network error occurred",
+        error
+      );
+      return Promise.reject(networkError);
+    }
+    const { status, data } = error.response;
+    if (status === 401 || status === 403) {
+      const authError = new SlotlyAuthError(
+        data?.error?.message || "Authentication failed",
+        data?.error?.details
+      );
+      return Promise.reject(authError);
+    }
+    if (data?.error) {
+      const apiError2 = new SlotlyApiError(
+        data.error.code || "API_ERROR",
+        data.error.message || "An error occurred",
+        status,
+        data.error.details
+      );
+      return Promise.reject(apiError2);
+    }
+    const apiError = new SlotlyApiError(
+      "HTTP_ERROR",
+      error.message || `Request failed with status ${status}`,
+      status,
+      data
+    );
+    return Promise.reject(apiError);
+  };
+}
+
+// src/retry.ts
+var import_axios = __toESM(require("axios"));
+var defaultRetryConfig = {
+  maxRetries: 3,
+  retryDelay: 1e3,
+  // 1 second
+  retryCondition: (error) => {
+    if (!error.response) {
+      return true;
+    }
+    const status = error.response.status;
+    return status >= 500 && status < 600;
+  }
+};
+function calculateRetryDelay(attempt, baseDelay) {
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  return exponentialDelay + jitter;
+}
+function setupRetryInterceptor(config = defaultRetryConfig) {
+  return async (error) => {
+    const requestConfig = error.config;
+    if (!requestConfig) {
+      return Promise.reject(error);
+    }
+    if (requestConfig._retryCount === void 0) {
+      requestConfig._retryCount = 0;
+    }
+    const shouldRetry = requestConfig._retryCount < config.maxRetries && (!config.retryCondition || config.retryCondition(error));
+    if (!shouldRetry) {
+      return Promise.reject(error);
+    }
+    requestConfig._retry = true;
+    requestConfig._retryCount += 1;
+    const delay = calculateRetryDelay(
+      requestConfig._retryCount - 1,
+      config.retryDelay
+    );
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return (0, import_axios.default)(requestConfig);
+  };
+}
+
+// src/middleware/validateSlotlyRequest.ts
+var import_jwt_decode = require("jwt-decode");
+var allowedKeys = {
+  "test-key-123": {
+    tenantId: "bright-accountants",
+    permissions: ["booking:create"]
+  },
+  "admin-ui": {
+    tenantId: "slotly-core",
+    permissions: ["*"]
+  }
+};
+function validateApiKey(clientKey) {
+  if (!clientKey || typeof clientKey !== "string") {
+    return null;
+  }
+  const keyInfo = allowedKeys[clientKey];
+  if (!keyInfo) {
+    return null;
+  }
+  return {
+    tenantId: keyInfo.tenantId,
+    permissions: keyInfo.permissions
+  };
+}
+function extractUserToken(authHeader) {
+  if (!authHeader || typeof authHeader !== "string") {
+    return null;
+  }
+  const bearerMatch = authHeader.match(/^Bearer\s+(.+)$/i);
+  if (!bearerMatch || !bearerMatch[1]) {
+    return null;
+  }
+  const token = bearerMatch[1];
+  try {
+    const claims = (0, import_jwt_decode.jwtDecode)(token);
+    if (!claims || typeof claims !== "object") {
+      console.error("[Slotly SDK] Invalid JWT token: claims is not an object");
+      return null;
+    }
+    const userId = claims.sub || claims.user_id || claims.userId;
+    return {
+      userId: typeof userId === "string" ? userId : void 0,
+      tokenClaims: claims
+    };
+  } catch (error) {
+    console.error("[Slotly SDK] Failed to decode JWT token:", error);
+    return null;
+  }
+}
+function validateAndExtractContext(req) {
+  const clientKey = req.headers["x-slotly-api-key"] || req.headers["X-Slotly-Api-Key"] || req.headers["x-slotly-api-key"];
+  if (!clientKey || typeof clientKey !== "string" || clientKey.trim().length === 0) {
+    const error = new SlotlyAuthError(
+      "Missing or invalid x-slotly-api-key header. API key is required.",
+      { header: "x-slotly-api-key" }
+    );
+    console.error("[Slotly SDK] Validation failed:", error.message);
+    throw error;
+  }
+  const keyInfo = validateApiKey(clientKey);
+  if (!keyInfo) {
+    const error = new SlotlyAuthError(
+      "Invalid API key. Client key not found in allowlist.",
+      { clientKey: clientKey.substring(0, 8) + "..." }
+    );
+    console.error("[Slotly SDK] Validation failed:", error.message);
+    throw error;
+  }
+  const authHeader = req.headers.authorization || req.headers.Authorization;
+  const tokenInfo = authHeader ? extractUserToken(authHeader) : null;
+  const context = {
+    clientKey,
+    tenantId: keyInfo.tenantId,
+    permissions: keyInfo.permissions,
+    ...tokenInfo?.userId && { userId: tokenInfo.userId },
+    ...tokenInfo?.tokenClaims && { tokenClaims: tokenInfo.tokenClaims }
+  };
+  return context;
+}
+function getSlotlyContext(req) {
+  const slotlyReq = req;
+  return slotlyReq.slotlyContext || null;
+}
+function validateSlotlyRequest(handler) {
+  return async (req, res) => {
+    try {
+      const context = validateAndExtractContext(req);
+      const slotlyReq = req;
+      slotlyReq.slotlyContext = context;
+      await handler(slotlyReq, res);
+    } catch (error) {
+      if (error instanceof SlotlyAuthError) {
+        console.error(
+          "[Slotly SDK] Authentication failed:",
+          error.message,
+          error.details
+        );
+        res.status(error.statusCode || 401).json({
+          success: false,
+          error: {
+            code: error.code,
+            message: error.message,
+            details: error.details
+          }
+        });
+        return;
+      }
+      console.error("[Slotly SDK] Unexpected error:", error);
+      res.status(500).json({
+        success: false,
+        error: {
+          code: "INTERNAL_ERROR",
+          message: "An unexpected error occurred"
+        }
+      });
+    }
+  };
+}
+
+// src/index.ts
+var defaultBaseURL = typeof process !== "undefined" && process.env?.SLOTLY_API_URL ? process.env.SLOTLY_API_URL : "https://api.slotly.dev";
+function createAuthenticatedClient(options) {
+  const client = import_axios2.default.create({
+    baseURL: options.baseURL || defaultBaseURL,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    },
+    timeout: 3e4
+    // 30 seconds
+  });
+  client.interceptors.request.use(
+    async (config) => {
+      try {
+        const [clientKeyPromise, userTokenPromise] = [
+          options.getClientKey(),
+          options.getUserToken?.() ?? Promise.resolve(null)
+        ];
+        const [clientKey, userToken] = await Promise.all([
+          clientKeyPromise,
+          userTokenPromise
+        ]);
+        if (!clientKey || typeof clientKey !== "string" || clientKey.trim().length === 0) {
+          throw new SlotlyConfigurationError(
+            "getClientKey() must return a non-empty string. API key is required for all requests.",
+            { received: clientKey }
+          );
+        }
+        config.headers["x-slotly-api-key"] = clientKey;
+        if (userToken && typeof userToken === "string" && userToken.trim().length > 0) {
+          config.headers["Authorization"] = `Bearer ${userToken}`;
+        }
+        return config;
+      } catch (error) {
+        if (error instanceof SlotlyConfigurationError) {
+          throw error;
+        }
+        if (error && typeof error === "object" && "message" in error) {
+          console.error("[Slotly SDK] Failed to retrieve authentication credentials:", error);
+          throw new SlotlyConfigurationError(
+            `Failed to retrieve authentication credentials: ${error.message}`,
+            { originalError: error }
+          );
+        }
+        throw error;
+      }
+    },
+    (error) => Promise.reject(error)
+  );
+  client.interceptors.request.use(setupRequestInterceptor());
+  client.interceptors.response.use(
+    (response) => setupResponseInterceptor()(response),
+    (error) => setupErrorInterceptor()(error)
+  );
+  client.interceptors.response.use(
+    (response) => response,
+    setupRetryInterceptor({
+      maxRetries: options.retry?.maxRetries ?? 3,
+      retryDelay: options.retry?.retryDelay ?? 1e3
+    })
+  );
+  return client;
+}
+var useSlotly = (options) => {
+  if (!options || typeof options !== "object") {
+    throw new SlotlyConfigurationError(
+      "useSlotly() requires an options object with getClientKey function"
+    );
+  }
+  if (!options.getClientKey || typeof options.getClientKey !== "function") {
+    throw new SlotlyConfigurationError(
+      "getClientKey must be a function that returns Promise<string>"
+    );
+  }
+  const client = createAuthenticatedClient(options);
+  return {
+    tenant: new TenantClient(client),
+    booking: new BookingClient(client),
+    service: new ServiceClient(client),
+    serviceItem: new ServiceItemClient(client),
+    slot: new SlotClient(client),
+    customer: new CustomerClient(client),
+    flow: new FlowClient(client),
+    studio: new StudioClient(client),
+    notification: new NotificationClient(client),
+    dataQuality: new DataQualityClient(client)
+  };
+};
+var index_default = useSlotly;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SlotlyApiError,
+  SlotlyAuthError,
+  SlotlyConfigurationError,
+  SlotlyNetworkError,
+  getSlotlyContext,
+  useSlotly,
+  validateSlotlyRequest
+});
+//# sourceMappingURL=index.cjs.js.map