@pinecall/pinecall-booking-sdk 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pinecall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,340 @@
+<div align="center">
+
+# @pinecall/pinecall-booking-sdk
+
+**Official JavaScript SDK for the Pinecall Booking API**
+
+[![npm version](https://img.shields.io/npm/v/@pinecall/pinecall-booking-sdk.svg)](https://www.npmjs.com/package/@pinecall/pinecall-booking-sdk)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+[Installation](#installation) •
+[Quick Start](#quick-start) •
+[API Reference](#api-reference) •
+[Examples](#examples) •
+[License](#license)
+
+</div>
+
+---
+
+## Installation
+
+```bash
+npm install @pinecall/pinecall-booking-sdk
+```
+
+---
+
+## Quick Start
+
+```javascript
+import { Pinecall } from '@pinecall/pinecall-booking-sdk';
+
+const client = new Pinecall('pk_your_api_key');
+
+// Create a restaurant booking system
+const config = await client.configurations.create({
+  name: 'My Restaurant',
+  businessType: 'restaurant',
+  resourceDefinition: {
+    name: 'table',
+    pluralName: 'tables',
+    attributes: [
+      { key: 'seats', type: 'number', required: true }
+    ]
+  },
+  businessRules: {
+    minBookingTime: '1h',
+    maxBookingTime: '3h',
+    bufferTime: '15m'
+  }
+});
+
+// Create tables
+await client.resources.bulkCreate({
+  configurationId: config.configuration._id,
+  resources: [
+    { name: 'Table 1', attributes: { seats: 2 } },
+    { name: 'Table 2', attributes: { seats: 4 } },
+    { name: 'Table 3', attributes: { seats: 6 } }
+  ]
+});
+
+// Check availability
+const availability = await client.availability.query({
+  configurationId: config.configuration._id,
+  startDate: '2025-01-20',
+  endDate: '2025-01-20'
+});
+
+// Create a booking
+const booking = await client.bookings.create({
+  configurationId: config.configuration._id,
+  resourceId: availability.resources[0]._id,
+  startTime: '2025-01-20T19:00:00Z',
+  endTime: '2025-01-20T21:00:00Z',
+  customer: {
+    name: 'John Doe',
+    email: 'john@example.com',
+    phone: '+1234567890'
+  },
+  attributes: {
+    partySize: 4
+  }
+});
+
+// Confirm the booking
+await client.bookings.confirm(booking.booking._id);
+```
+
+---
+
+## API Reference
+
+### Client Initialization
+
+```javascript
+import { Pinecall } from '@pinecall/pinecall-booking-sdk';
+
+// Simple
+const client = new Pinecall('pk_your_api_key');
+
+// With options
+const client = new Pinecall('pk_your_api_key', {
+  baseUrl: 'https://api.example.com',  // Custom API URL
+  timeout: 30000,                       // Request timeout (ms)
+  maxRetries: 3                         // Retry attempts
+});
+```
+
+### Configurations
+
+```javascript
+// List all configurations
+const configs = await client.configurations.list();
+
+// Get a specific configuration
+const config = await client.configurations.get('config_id');
+
+// Create a configuration
+const config = await client.configurations.create({
+  name: 'My Business',
+  businessType: 'restaurant',
+  resourceDefinition: { ... },
+  bookingDefinition: { ... },
+  businessRules: { ... },
+  defaultSchedule: [ ... ]
+});
+
+// Update a configuration
+await client.configurations.update('config_id', { name: 'New Name' });
+```
+
+### Resources
+
+```javascript
+// List resources
+const resources = await client.resources.list('config_id');
+
+// List with filters
+const tables = await client.resources.list('config_id', {
+  seats: { $gte: 4 }
+});
+
+// Get a resource
+const resource = await client.resources.get('resource_id');
+
+// Create a resource
+const resource = await client.resources.create({
+  configurationId: 'config_id',
+  name: 'Table 5',
+  attributes: { seats: 4, location: 'terrace' }
+});
+
+// Bulk create resources
+const result = await client.resources.bulkCreate({
+  configurationId: 'config_id',
+  resources: [
+    { name: 'Table 1', attributes: { seats: 2 } },
+    { name: 'Table 2', attributes: { seats: 4 } }
+  ]
+});
+
+// Update a resource
+await client.resources.update('resource_id', { name: 'VIP Table' });
+
+// Delete a resource
+await client.resources.delete('resource_id');
+```
+
+### Availability
+
+```javascript
+// Query available slots
+const availability = await client.availability.query({
+  configurationId: 'config_id',
+  startDate: '2025-01-20',
+  endDate: '2025-01-20'
+});
+
+// Query with filters
+const availability = await client.availability.query({
+  configurationId: 'config_id',
+  startDate: '2025-01-20',
+  endDate: '2025-01-20',
+  duration: 60,
+  resourceFilters: { seats: { $gte: 4 } }
+});
+
+// Check specific slot
+const isAvailable = await client.availability.check(
+  'resource_id',
+  '2025-01-20T19:00:00Z',
+  '2025-01-20T21:00:00Z'
+);
+```
+
+### Bookings
+
+```javascript
+// Create a booking
+const booking = await client.bookings.create({
+  configurationId: 'config_id',
+  resourceId: 'resource_id',
+  startTime: '2025-01-20T19:00:00Z',
+  endTime: '2025-01-20T21:00:00Z',
+  customer: {
+    name: 'John Doe',
+    email: 'john@example.com'
+  },
+  attributes: {
+    partySize: 4
+  }
+});
+
+// Get a booking
+const booking = await client.bookings.get('booking_id');
+
+// List bookings
+const bookings = await client.bookings.list({
+  configurationId: 'config_id',
+  startDate: '2025-01-01',
+  endDate: '2025-01-31'
+});
+
+// List with filters
+const bookings = await client.bookings.list({
+  configurationId: 'config_id',
+  startDate: '2025-01-01',
+  endDate: '2025-01-31',
+  status: 'confirmed',
+  resourceId: 'resource_id'
+});
+
+// Confirm a booking
+await client.bookings.confirm('booking_id');
+
+// Cancel a booking
+await client.bookings.cancel('booking_id', 'Customer request');
+
+// Reschedule a booking
+await client.bookings.reschedule(
+  'booking_id',
+  '2025-01-21T19:00:00Z',
+  '2025-01-21T21:00:00Z'
+);
+
+// Mark as completed
+await client.bookings.complete('booking_id');
+
+// Mark as no-show
+await client.bookings.noShow('booking_id');
+
+// Get statistics
+const stats = await client.bookings.stats('config_id', '2025-01-01', '2025-01-31');
+```
+
+### Static Helpers
+
+```javascript
+import { Pinecall } from '@pinecall/pinecall-booking-sdk';
+
+// Get date N days in the future (YYYY-MM-DD)
+Pinecall.futureDate(7);        // '2025-01-27'
+
+// Get datetime N days in the future at specific time
+Pinecall.futureDateTime(7, 19, 0);  // '2025-01-27T19:00:00.000Z'
+
+// Format date for API
+Pinecall.formatDate(new Date());     // '2025-01-20'
+
+// Format datetime for API
+Pinecall.formatDateTime(new Date()); // '2025-01-20T15:30:00.000Z'
+```
+
+---
+
+## Error Handling
+
+```javascript
+import { Pinecall, PinecallError, ValidationError, NotFoundError, ConflictError } from '@pinecall/pinecall-booking-sdk';
+
+try {
+  const booking = await client.bookings.create({ ... });
+} catch (error) {
+  if (error instanceof ValidationError) {
+    console.log('Invalid data:', error.message);
+  } else if (error instanceof NotFoundError) {
+    console.log('Resource not found:', error.message);
+  } else if (error instanceof ConflictError) {
+    console.log('Booking conflict:', error.message);
+  } else if (error instanceof PinecallError) {
+    console.log('API error:', error.message, error.statusCode);
+  }
+}
+```
+
+---
+
+## Constants
+
+```javascript
+import { BOOKING_STATUS, BUSINESS_TYPES } from '@pinecall/pinecall-booking-sdk';
+
+BOOKING_STATUS.PENDING    // 'pending'
+BOOKING_STATUS.CONFIRMED  // 'confirmed'
+BOOKING_STATUS.CANCELLED  // 'cancelled'
+BOOKING_STATUS.COMPLETED  // 'completed'
+BOOKING_STATUS.NO_SHOW    // 'no_show'
+
+BUSINESS_TYPES.RESTAURANT // 'restaurant'
+BUSINESS_TYPES.SPA        // 'spa'
+BUSINESS_TYPES.HOTEL      // 'hotel'
+BUSINESS_TYPES.CLINIC     // 'clinic'
+BUSINESS_TYPES.SPORTS     // 'sports'
+BUSINESS_TYPES.COWORKING  // 'coworking'
+BUSINESS_TYPES.CUSTOM     // 'custom'
+```
+
+---
+
+## Examples
+
+See the [examples](./examples) directory for complete working examples:
+
+- [Restaurant Booking](./examples/basic.js) - Tables, time slots, reservations
+- [Spa Appointments](./examples/spa.js) - Therapists, treatments, scheduling
+
+---
+
+## Requirements
+
+- Node.js >= 18.0.0
+- ES Modules support
+
+---
+
+## License
+
+MIT © [Pinecall](https://pinecall.io)

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@pinecall/pinecall-booking-sdk",
+  "version": "1.0.1",
+  "description": "Simple, elegant SDK for Pinecall Booking API. Zero dependencies.",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    }
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "test:watch": "node --test --watch test/*.test.js",
+    "example": "node examples/basic.js"
+  },
+  "keywords": [
+    "booking",
+    "reservations",
+    "scheduling",
+    "api",
+    "sdk",
+    "pinecall",
+    "restaurant",
+    "appointments"
+  ],
+  "author": "Pinecall <support@pinecall.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinecall/pinecall-booking-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pinecall/pinecall-booking-sdk/issues"
+  },
+  "homepage": "https://pinecall.io/docs/pinecall-booking-sdk",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/client.js

@@ -0,0 +1,121 @@
+import { HttpClient } from './http.js';
+import { Configurations } from './resources/configurations.js';
+import { Resources } from './resources/resources.js';
+import { Availability } from './resources/availability.js';
+import { Bookings } from './resources/bookings.js';
+import { ValidationError } from './errors.js';
+
+/**
+ * Pinecall Booking SDK Client
+ * 
+ * A simple, elegant client for the Pinecall Booking API.
+ * Inspired by Stripe's SDK design.
+ * 
+ * @example
+ * ```js
+ * import { Pinecall } from '@pinecall/booking-sdk';
+ * 
+ * const client = new Pinecall('pk_your_api_key');
+ * 
+ * // Or with options
+ * const client = new Pinecall('pk_your_api_key', {
+ *   baseUrl: 'https://api.pinecall.com',
+ *   timeout: 30000
+ * });
+ * ```
+ */
+export class Pinecall {
+  /** @type {Configurations} */
+  configurations;
+  
+  /** @type {Resources} */
+  resources;
+  
+  /** @type {Availability} */
+  availability;
+  
+  /** @type {Bookings} */
+  bookings;
+
+  /**
+   * Create a new Pinecall client
+   * @param {string} apiKey - Your Pinecall API key
+   * @param {Object} [options]
+   * @param {string} [options.baseUrl='https://api.pinecall.com'] - API base URL
+   * @param {number} [options.timeout=30000] - Request timeout in milliseconds
+   * @param {number} [options.maxRetries=3] - Maximum retry attempts
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey || typeof apiKey !== 'string') {
+      throw new ValidationError('API key is required');
+    }
+
+    const http = new HttpClient({
+      apiKey,
+      baseUrl: options.baseUrl || 'https://api.pinecall.com',
+      timeout: options.timeout || 30000,
+      maxRetries: options.maxRetries || 3
+    });
+
+    // Initialize resource managers
+    this.configurations = new Configurations(http);
+    this.resources = new Resources(http);
+    this.availability = new Availability(http);
+    this.bookings = new Bookings(http);
+  }
+
+  // ═══════════════════════════════════════════════════════════════
+  // STATIC HELPERS
+  // ═══════════════════════════════════════════════════════════════
+
+  /**
+   * Get a date string for N days in the future
+   * @param {number} [days=1] - Days ahead
+   * @returns {string} Date string (YYYY-MM-DD)
+   * 
+   * @example
+   * Pinecall.futureDate(7) // '2025-01-27'
+   */
+  static futureDate(days = 1) {
+    const date = new Date();
+    date.setDate(date.getDate() + days);
+    return date.toISOString().split('T')[0];
+  }
+
+  /**
+   * Get a datetime string for N days in the future at specific time
+   * @param {number} [days=1] - Days ahead
+   * @param {number} [hour=12] - Hour (0-23)
+   * @param {number} [minute=0] - Minute (0-59)
+   * @returns {string} ISO 8601 datetime string
+   * 
+   * @example
+   * Pinecall.futureDateTime(7, 19, 0) // '2025-01-27T19:00:00.000Z'
+   */
+  static futureDateTime(days = 1, hour = 12, minute = 0) {
+    const date = new Date();
+    date.setDate(date.getDate() + days);
+    date.setUTCHours(hour, minute, 0, 0);
+    return date.toISOString();
+  }
+
+  /**
+   * Format a Date object to API date format
+   * @param {Date|string} date - Date to format
+   * @returns {string} Date string (YYYY-MM-DD)
+   */
+  static formatDate(date) {
+    const d = typeof date === 'string' ? new Date(date) : date;
+    return d.toISOString().split('T')[0];
+  }
+
+  /**
+   * Format a Date object to API datetime format
+   * @param {Date|string} date - Date to format
+   * @returns {string} ISO 8601 datetime string
+   */
+  static formatDateTime(date) {
+    const d = typeof date === 'string' ? new Date(date) : date;
+    return d.toISOString();
+  }
+}

package/src/constants.js

@@ -0,0 +1,41 @@
+/**
+ * Booking status constants
+ * @readonly
+ * @enum {string}
+ */
+export const BOOKING_STATUS = Object.freeze({
+  PENDING: 'pending',
+  CONFIRMED: 'confirmed',
+  CANCELLED: 'cancelled',
+  COMPLETED: 'completed',
+  NO_SHOW: 'no_show'
+});
+
+/**
+ * Common business types
+ * @readonly
+ * @enum {string}
+ */
+export const BUSINESS_TYPES = Object.freeze({
+  RESTAURANT: 'restaurant',
+  SPA: 'spa',
+  SALON: 'salon',
+  HOTEL: 'hotel',
+  SPORTS: 'sports',
+  COWORKING: 'coworking',
+  MEDICAL: 'medical',
+  CUSTOM: 'custom'
+});
+
+/**
+ * Booking actions
+ * @readonly
+ * @enum {string}
+ */
+export const BOOKING_ACTIONS = Object.freeze({
+  CONFIRM: 'confirm',
+  CANCEL: 'cancel',
+  COMPLETE: 'complete',
+  NO_SHOW: 'no_show',
+  RESCHEDULE: 'reschedule'
+});

package/src/errors.js

@@ -0,0 +1,78 @@
+/**
+ * Base error class for Pinecall SDK
+ */
+export class PinecallError extends Error {
+  /**
+   * @param {string} message - Error message
+   * @param {string} [code] - Error code
+   * @param {number} [status] - HTTP status code
+   * @param {Object} [details] - Additional error details
+   */
+  constructor(message, code = 'PINECALL_ERROR', status = 500, details = {}) {
+    super(message);
+    this.name = 'PinecallError';
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      details: this.details
+    };
+  }
+}
+
+/**
+ * Validation error (400)
+ */
+export class ValidationError extends PinecallError {
+  constructor(message, details = {}) {
+    super(message, 'VALIDATION_ERROR', 400, details);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Not found error (404)
+ */
+export class NotFoundError extends PinecallError {
+  constructor(message = 'Resource not found', details = {}) {
+    super(message, 'NOT_FOUND', 404, details);
+    this.name = 'NotFoundError';
+  }
+}
+
+/**
+ * Conflict error (409) - e.g., double booking
+ */
+export class ConflictError extends PinecallError {
+  constructor(message = 'Resource conflict', details = {}) {
+    super(message, 'CONFLICT', 409, details);
+    this.name = 'ConflictError';
+  }
+}
+
+/**
+ * Authentication error (401)
+ */
+export class AuthenticationError extends PinecallError {
+  constructor(message = 'Invalid API key') {
+    super(message, 'UNAUTHORIZED', 401);
+    this.name = 'AuthenticationError';
+  }
+}
+
+/**
+ * Rate limit error (429)
+ */
+export class RateLimitError extends PinecallError {
+  constructor(message = 'Rate limit exceeded', retryAfter = 60) {
+    super(message, 'RATE_LIMIT', 429, { retryAfter });
+    this.name = 'RateLimitError';
+  }
+}

package/src/http.js

@@ -0,0 +1,156 @@
+import { PinecallError, AuthenticationError, NotFoundError, ValidationError, RateLimitError } from './errors.js';
+
+/**
+ * HTTP client with retry logic and error handling
+ */
+export class HttpClient {
+  #apiKey;
+  #baseUrl;
+  #timeout;
+  #maxRetries;
+
+  /**
+   * @param {Object} config
+   * @param {string} config.apiKey - API key
+   * @param {string} [config.baseUrl] - Base URL
+   * @param {number} [config.timeout] - Request timeout in ms
+   * @param {number} [config.maxRetries] - Max retry attempts
+   */
+  constructor({ apiKey, baseUrl = 'https://api.pinecall.com', timeout = 30000, maxRetries = 3 }) {
+    this.#apiKey = apiKey;
+    this.#baseUrl = baseUrl.replace(/\/$/, '');
+    this.#timeout = timeout;
+    this.#maxRetries = maxRetries;
+  }
+
+  /**
+   * Make HTTP request with automatic retry
+   * @param {string} method - HTTP method
+   * @param {string} path - API path
+   * @param {Object} [options] - Request options
+   * @returns {Promise<any>}
+   */
+  async request(method, path, options = {}) {
+    const url = `${this.#baseUrl}${path}`;
+    const { body, query, headers: customHeaders = {} } = options;
+
+    // Build URL with query params
+    const urlWithQuery = query 
+      ? `${url}?${new URLSearchParams(this.#flattenQuery(query))}` 
+      : url;
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'X-API-Key': this.#apiKey,
+      'User-Agent': '@pinecall/booking-sdk/1.0.0',
+      ...customHeaders
+    };
+
+    const fetchOptions = {
+      method,
+      headers,
+      ...(body && { body: JSON.stringify(body) })
+    };
+
+    return this.#executeWithRetry(urlWithQuery, fetchOptions);
+  }
+
+  /**
+   * Execute request with retry logic
+   */
+  async #executeWithRetry(url, options, attempt = 1) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.#timeout);
+
+    try {
+      const response = await fetch(url, { ...options, signal: controller.signal });
+      clearTimeout(timeoutId);
+
+      const data = await response.json().catch(() => ({}));
+
+      if (!response.ok) {
+        throw this.#createError(response.status, data);
+      }
+
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      // Retry on network errors or 5xx
+      if (this.#shouldRetry(error, attempt)) {
+        const delay = this.#getRetryDelay(attempt);
+        await this.#sleep(delay);
+        return this.#executeWithRetry(url, options, attempt + 1);
+      }
+
+      if (error.name === 'AbortError') {
+        throw new PinecallError(`Request timeout after ${this.#timeout}ms`, 'TIMEOUT', 408);
+      }
+
+      throw error instanceof PinecallError ? error : new PinecallError(error.message);
+    }
+  }
+
+  /**
+   * Create appropriate error from response
+   */
+  #createError(status, data) {
+    const message = data.error || data.message || 'Unknown error';
+
+    switch (status) {
+      case 400: return new ValidationError(message, data.details);
+      case 401: return new AuthenticationError(message);
+      case 404: return new NotFoundError(message);
+      case 429: return new RateLimitError(message, data.retryAfter);
+      default: return new PinecallError(message, data.code || 'API_ERROR', status, data);
+    }
+  }
+
+  #shouldRetry(error, attempt) {
+    if (attempt >= this.#maxRetries) return false;
+    if (error instanceof RateLimitError) return true;
+    if (error.status >= 500) return true;
+    if (error.name === 'AbortError') return true;
+    return false;
+  }
+
+  #getRetryDelay(attempt) {
+    // Exponential backoff: 1s, 2s, 4s...
+    return Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+  }
+
+  #sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  #flattenQuery(query, prefix = '') {
+    const params = {};
+    
+    for (const [key, value] of Object.entries(query)) {
+      if (value === undefined || value === null) continue;
+      
+      const paramKey = prefix ? `${prefix}_${key}` : key;
+      
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        // For attribute filters, stringify the object
+        if (key.startsWith('attr') || prefix === 'attr') {
+          params[paramKey] = JSON.stringify(value);
+        } else {
+          Object.assign(params, this.#flattenQuery(value, paramKey));
+        }
+      } else if (Array.isArray(value)) {
+        params[paramKey] = value.join(',');
+      } else {
+        params[paramKey] = String(value);
+      }
+    }
+    
+    return params;
+  }
+
+  // Convenience methods
+  get(path, query) { return this.request('GET', path, { query }); }
+  post(path, body) { return this.request('POST', path, { body }); }
+  put(path, body) { return this.request('PUT', path, { body }); }
+  delete(path, body) { return this.request('DELETE', path, { body }); }
+}

package/src/index.js

@@ -0,0 +1,20 @@
+/**
+ * @pinecall/booking-sdk
+ * 
+ * Simple, elegant SDK for Pinecall Booking API.
+ * Zero dependencies. Full JSDoc support.
+ * 
+ * @example
+ * ```js
+ * import { Pinecall } from '@pinecall/booking-sdk';
+ * 
+ * const client = new Pinecall('pk_your_api_key');
+ * const config = await client.configurations.create({ name: 'My Restaurant' });
+ * ```
+ * 
+ * @module @pinecall/booking-sdk
+ */
+
+export { Pinecall } from './client.js';
+export { PinecallError, ValidationError, NotFoundError, ConflictError } from './errors.js';
+export { BOOKING_STATUS, BUSINESS_TYPES } from './constants.js';

package/src/resources/availability.js

@@ -0,0 +1,44 @@
+/**
+ * Availability - Query available time slots
+ */
+export class Availability {
+  #http;
+
+  constructor(http) {
+    this.#http = http;
+  }
+
+  /**
+   * Query available slots
+   * @param {Object} params
+   * @returns {Promise<{summary: Object, resources: Array, availableSlots: Array}>}
+   */
+  query(params) {
+    const query = {
+      configId: params.configurationId,
+      startDate: params.startDate,
+      endDate: params.endDate
+    };
+
+    if (params.duration) {
+      query.duration = params.duration;
+    }
+
+    if (params.resourceFilters) {
+      for (const [key, value] of Object.entries(params.resourceFilters)) {
+        query[`attr_${key}`] = typeof value === 'object' ? JSON.stringify(value) : value;
+      }
+    }
+
+    return this.#http.get('/api/bookings/availability', query);
+  }
+
+  /**
+   * Check if a specific slot is available
+   * @param {Object} params
+   * @returns {Promise<{available: boolean, reason?: string}>}
+   */
+  check(params) {
+    return this.#http.post('/api/bookings/availability', params);
+  }
+}

package/src/resources/bookings.js

@@ -0,0 +1,126 @@
+import { BOOKING_ACTIONS } from '../constants.js';
+
+/**
+ * Bookings - Create and manage reservations
+ */
+export class Bookings {
+  #http;
+
+  constructor(http) {
+    this.#http = http;
+  }
+
+  /**
+   * List bookings
+   * @param {Object} params
+   * @returns {Promise<{bookings: Array}>}
+   */
+  list(params) {
+    const query = {
+      configId: params.configurationId,
+      startDate: params.startDate,
+      endDate: params.endDate
+    };
+
+    if (params.status) {
+      query.status = Array.isArray(params.status) ? params.status.join(',') : params.status;
+    }
+    if (params.resourceId) query.resourceId = params.resourceId;
+    if (params.search) query.search = params.search;
+
+    return this.#http.get('/api/bookings/manage', query);
+  }
+
+  /**
+   * Get a booking by ID
+   * @param {string} id - Booking ID
+   * @returns {Promise<{booking: Object}>}
+   */
+  get(id) {
+    return this.#http.get('/api/bookings/manage', { id });
+  }
+
+  /**
+   * Create a new booking
+   * @param {Object} params
+   * @returns {Promise<{booking: Object}>}
+   */
+  create(params) {
+    return this.#http.post('/api/bookings/create', params);
+  }
+
+  /**
+   * Confirm a booking
+   * @param {string} id - Booking ID
+   * @param {string} [reason] - Reason
+   * @returns {Promise<{booking: Object}>}
+   */
+  confirm(id, reason) {
+    return this.#action(id, BOOKING_ACTIONS.CONFIRM, { reason });
+  }
+
+  /**
+   * Cancel a booking
+   * @param {string} id - Booking ID
+   * @param {string} [reason] - Reason
+   * @returns {Promise<{booking: Object}>}
+   */
+  cancel(id, reason) {
+    return this.#action(id, BOOKING_ACTIONS.CANCEL, { reason });
+  }
+
+  /**
+   * Mark booking as completed
+   * @param {string} id - Booking ID
+   * @param {string} [reason] - Reason
+   * @returns {Promise<{booking: Object}>}
+   */
+  complete(id, reason) {
+    return this.#action(id, BOOKING_ACTIONS.COMPLETE, { reason });
+  }
+
+  /**
+   * Mark booking as no-show
+   * @param {string} id - Booking ID
+   * @param {string} [reason] - Reason
+   * @returns {Promise<{booking: Object}>}
+   */
+  noShow(id, reason) {
+    return this.#action(id, BOOKING_ACTIONS.NO_SHOW, { reason });
+  }
+
+  /**
+   * Reschedule a booking
+   * @param {string} id - Booking ID
+   * @param {Object} params
+   * @returns {Promise<{booking: Object}>}
+   */
+  reschedule(id, params) {
+    return this.#action(id, BOOKING_ACTIONS.RESCHEDULE, {
+      newStartTime: params.newStartTime,
+      newEndTime: params.newEndTime
+    });
+  }
+
+  /**
+   * Get booking statistics
+   * @param {string} configId - Configuration ID
+   * @param {Object} [params]
+   * @returns {Promise<{stats: Object}>}
+   */
+  stats(configId, params = {}) {
+    return this.#http.get('/api/bookings/manage', {
+      configId,
+      stats: 'true',
+      ...params
+    });
+  }
+
+  #action(bookingId, action, params = {}) {
+    return this.#http.post('/api/bookings/manage', {
+      bookingId,
+      action,
+      ...params
+    });
+  }
+}

package/src/resources/configurations.js

@@ -0,0 +1,46 @@
+/**
+ * Configuration resource - Manage booking system configurations
+ */
+export class Configurations {
+  #http;
+
+  constructor(http) {
+    this.#http = http;
+  }
+
+  /**
+   * List all configurations
+   * @returns {Promise<{configurations: Array}>}
+   */
+  list() {
+    return this.#http.get('/api/bookings/configure');
+  }
+
+  /**
+   * Get a configuration by ID
+   * @param {string} id - Configuration ID
+   * @returns {Promise<{configuration: Object}>}
+   */
+  get(id) {
+    return this.#http.get('/api/bookings/configure', { id });
+  }
+
+  /**
+   * Create a new configuration
+   * @param {Object} params
+   * @returns {Promise<{configuration: Object}>}
+   */
+  create(params) {
+    return this.#http.post('/api/bookings/configure', params);
+  }
+
+  /**
+   * Update a configuration
+   * @param {string} id - Configuration ID
+   * @param {Object} params - Fields to update
+   * @returns {Promise<{configuration: Object}>}
+   */
+  update(id, params) {
+    return this.#http.put('/api/bookings/configure', { configurationId: id, ...params });
+  }
+}

package/src/resources/resources.js

@@ -0,0 +1,72 @@
+/**
+ * Resources - Manage bookable entities (tables, rooms, vehicles, etc.)
+ */
+export class Resources {
+  #http;
+
+  constructor(http) {
+    this.#http = http;
+  }
+
+  /**
+   * List resources for a configuration
+   * @param {string} configId - Configuration ID
+   * @param {Object} [filters] - Attribute filters
+   * @returns {Promise<{resources: Array, count: number}>}
+   */
+  list(configId, filters = {}) {
+    const query = { configId };
+    
+    for (const [key, value] of Object.entries(filters)) {
+      query[`attr_${key}`] = typeof value === 'object' ? JSON.stringify(value) : value;
+    }
+    
+    return this.#http.get('/api/bookings/resources', query);
+  }
+
+  /**
+   * Get a resource by ID
+   * @param {string} id - Resource ID
+   * @returns {Promise<{resource: Object}>}
+   */
+  get(id) {
+    return this.#http.get('/api/bookings/resources', { id });
+  }
+
+  /**
+   * Create a single resource
+   * @param {Object} params
+   * @returns {Promise<{resource: Object}>}
+   */
+  create(params) {
+    return this.#http.post('/api/bookings/resources', params);
+  }
+
+  /**
+   * Bulk create resources
+   * @param {Object} params
+   * @returns {Promise<{created: number, resources: Array}>}
+   */
+  bulkCreate(params) {
+    return this.#http.post('/api/bookings/resources', params);
+  }
+
+  /**
+   * Update a resource
+   * @param {string} id - Resource ID
+   * @param {Object} params - Fields to update
+   * @returns {Promise<{resource: Object}>}
+   */
+  update(id, params) {
+    return this.#http.put('/api/bookings/resources', { resourceId: id, ...params });
+  }
+
+  /**
+   * Delete a resource
+   * @param {string} id - Resource ID
+   * @returns {Promise<{success: boolean}>}
+   */
+  delete(id) {
+    return this.#http.delete('/api/bookings/resources', { resourceId: id });
+  }
+}