orita-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,299 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OritaAuthError: () => OritaAuthError,
+  OritaClient: () => OritaClient,
+  OritaError: () => OritaError,
+  OritaNotFoundError: () => OritaNotFoundError,
+  OritaSlotUnavailableError: () => OritaSlotUnavailableError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var OritaError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "OritaError";
+    this.statusCode = statusCode;
+    this.response = response;
+    const ErrCtor = Error;
+    if (ErrCtor.captureStackTrace) {
+      ErrCtor.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var OritaAuthError = class extends OritaError {
+  constructor(message = "Invalid or missing API key", response) {
+    super(message, 401, response);
+    this.name = "OritaAuthError";
+  }
+};
+var OritaNotFoundError = class extends OritaError {
+  constructor(message = "Resource not found", response) {
+    super(message, 404, response);
+    this.name = "OritaNotFoundError";
+  }
+};
+var OritaSlotUnavailableError = class extends OritaError {
+  constructor(message = "Slot is no longer available", response) {
+    super(message, 409, response);
+    this.name = "OritaSlotUnavailableError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://orita.online/api/v1";
+var OritaClient = class {
+  constructor(options) {
+    const { apiKey, baseUrl = DEFAULT_BASE_URL } = options;
+    if (!apiKey.startsWith("orita_")) {
+      throw new OritaAuthError("API key must start with 'orita_'");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.params);
+    const init = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    };
+    if (options.body !== void 0) {
+      init.body = JSON.stringify(options.body);
+    }
+    let res;
+    try {
+      res = await fetch(url, init);
+    } catch (err) {
+      throw new OritaError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch {
+      throw new OritaError(`Invalid JSON response (HTTP ${res.status})`);
+    }
+    if (res.status === 401) {
+      const msg = json?.error ?? "Invalid or missing API key";
+      throw new OritaAuthError(msg, json);
+    }
+    if (res.status === 404) {
+      const msg = json?.error ?? "Resource not found";
+      throw new OritaNotFoundError(msg, json);
+    }
+    if (res.status === 409) {
+      const msg = json?.error ?? "Slot is no longer available";
+      throw new OritaSlotUnavailableError(msg, json);
+    }
+    if (!res.ok) {
+      const msg = json?.error ?? `HTTP ${res.status}`;
+      throw new OritaError(msg, res.status, json);
+    }
+    return json;
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  /**
+   * List all active event types for your account.
+   *
+   * @example
+   * const eventTypes = await orita.getEventTypes();
+   * // [{ id: "evt_abc123", title: "Initial Consultation", duration: 30, ... }]
+   */
+  async getEventTypes() {
+    const res = await this.request("GET", "/event-types");
+    return res.data;
+  }
+  /**
+   * Get available time slots for an event type on a given date.
+   *
+   * @param eventTypeId - Event type ID from `getEventTypes()`
+   * @param date - Date in `YYYY-MM-DD` format
+   *
+   * @example
+   * const { slots } = await orita.getSlots('evt_abc123', '2026-08-01');
+   * // [{ label: "09:00 AM", value: "09:00" }, ...]
+   */
+  async getSlots(eventTypeId, date) {
+    const res = await this.request(
+      "GET",
+      "/slots",
+      { params: { eventTypeId, date } }
+    );
+    return res;
+  }
+  /**
+   * Book an appointment. Returns the created booking object.
+   *
+   * @example
+   * const booking = await orita.book({
+   *   eventTypeId: 'evt_abc123',
+   *   date: '2026-08-01',
+   *   time: '10:00',
+   *   clientName: 'Ana',
+   *   clientLastname: 'López',
+   *   clientEmail: 'ana@example.com',
+   * });
+   * console.log(booking.id); // "book_xyz789"
+   */
+  async book(params) {
+    const body = {
+      eventTypeId: params.eventTypeId,
+      date: params.date,
+      time: params.time,
+      clientName: params.clientName,
+      clientLastname: params.clientLastname,
+      clientEmail: params.clientEmail
+    };
+    if (params.clientPhone) body.clientPhone = params.clientPhone;
+    if (params.clientTimezone) body.clientTimezone = params.clientTimezone;
+    if (params.notes) body.notes = params.notes;
+    const res = await this.request("POST", "/bookings", { body });
+    return res.data;
+  }
+  /**
+   * List your bookings with optional filtering.
+   *
+   * @example
+   * const bookings = await orita.getBookings({ status: 'confirmed' });
+   */
+  async getBookings(params = {}) {
+    const query = {};
+    if (params.page !== void 0) query.page = String(params.page);
+    if (params.limit !== void 0) query.limit = String(params.limit);
+    if (params.status) query.status = params.status;
+    const res = await this.request("GET", "/bookings", { params: query });
+    return res.data;
+  }
+  /**
+   * Retrieve a single booking by ID.
+   *
+   * @example
+   * const booking = await orita.getBooking('book_xyz789');
+   * console.log(booking.status); // "confirmed"
+   */
+  async getBooking(bookingId) {
+    const res = await this.request("GET", `/bookings/${bookingId}`);
+    return res.data;
+  }
+  /**
+   * Cancel a booking by ID.
+   *
+   * @param bookingId - The booking ID to cancel
+   * @param reason - Optional cancellation reason
+   *
+   * @example
+   * const result = await orita.cancelBooking('book_xyz789', 'Client requested reschedule');
+   */
+  async cancelBooking(bookingId, reason) {
+    const body = {};
+    if (reason) body.reason = reason;
+    const res = await this.request(
+      "POST",
+      `/bookings/${bookingId}/cancel`,
+      { body: Object.keys(body).length ? body : void 0 }
+    );
+    return res.data;
+  }
+  /**
+   * Get your own Capability Manifest (your profile).
+   * Requires authentication.
+   *
+   * @example
+   * const profile = await orita.getMyProfile();
+   * console.log(profile.username);
+   */
+  async getMyProfile() {
+    const res = await this.request("GET", "/profile");
+    return res.data;
+  }
+  /**
+   * Update your profile fields.
+   *
+   * @example
+   * const updated = await orita.updateProfile({ bio: 'AI-native therapist' });
+   */
+  async updateProfile(fields) {
+    const res = await this.request("PUT", "/profile", { body: fields });
+    return res.data;
+  }
+  /**
+   * Fetch the **public** Capability Manifest for any professional by username.
+   * No API key is needed for this request.
+   *
+   * @param username - The professional's username (e.g. "dra-martinez")
+   *
+   * @example
+   * const manifest = await orita.getProfile('dra-martinez');
+   * console.log(manifest.eventTypes);
+   */
+  async getProfile(username) {
+    const url = this.buildUrl("/profile", { username });
+    let res;
+    try {
+      res = await fetch(url, {
+        headers: { Accept: "application/json" }
+      });
+    } catch (err) {
+      throw new OritaError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch {
+      throw new OritaError(`Invalid JSON response (HTTP ${res.status})`);
+    }
+    if (res.status === 404) {
+      throw new OritaNotFoundError(`Professional '${username}' not found`, json);
+    }
+    if (!res.ok) {
+      const msg = json?.error ?? `HTTP ${res.status}`;
+      throw new OritaError(msg, res.status, json);
+    }
+    return json.data;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OritaAuthError,
+  OritaClient,
+  OritaError,
+  OritaNotFoundError,
+  OritaSlotUnavailableError
+});

package/dist/index.d.cts

@@ -0,0 +1,202 @@
+interface EventType {
+    id: string;
+    title: string;
+    slug: string;
+    duration: number;
+    description?: string;
+    location?: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Slot {
+    label: string;
+    value: string;
+}
+interface SlotsResponse {
+    slots: Slot[];
+    date: string;
+    eventTypeId: string;
+}
+interface Booking {
+    id: string;
+    eventTypeId: string;
+    date: string;
+    time: string;
+    status: 'confirmed' | 'cancelled' | 'completed' | 'pending';
+    clientName: string;
+    clientLastname: string;
+    clientEmail: string;
+    clientPhone?: string;
+    clientTimezone?: string;
+    notes?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface BookingParams {
+    eventTypeId: string;
+    date: string;
+    time: string;
+    clientName: string;
+    clientLastname: string;
+    clientEmail: string;
+    clientPhone?: string;
+    clientTimezone?: string;
+    notes?: string;
+}
+interface BookingsListParams {
+    page?: number;
+    limit?: number;
+    status?: 'confirmed' | 'cancelled' | 'completed' | 'pending';
+}
+interface Profile {
+    username: string;
+    bio?: string;
+    timezone?: string;
+    eventTypes: EventType[];
+    [key: string]: unknown;
+}
+interface UpdateProfileParams {
+    bio?: string;
+    timezone?: string;
+    [key: string]: unknown;
+}
+
+interface OritaClientOptions {
+    /**
+     * Your Orita API key (must start with `orita_`).
+     * Get yours at https://orita.online/developers
+     */
+    apiKey: string;
+    /**
+     * Override the base URL (for self-hosted or staging environments).
+     * @default "https://orita.online/api/v1"
+     */
+    baseUrl?: string;
+}
+declare class OritaClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(options: OritaClientOptions);
+    private buildUrl;
+    private request;
+    /**
+     * List all active event types for your account.
+     *
+     * @example
+     * const eventTypes = await orita.getEventTypes();
+     * // [{ id: "evt_abc123", title: "Initial Consultation", duration: 30, ... }]
+     */
+    getEventTypes(): Promise<EventType[]>;
+    /**
+     * Get available time slots for an event type on a given date.
+     *
+     * @param eventTypeId - Event type ID from `getEventTypes()`
+     * @param date - Date in `YYYY-MM-DD` format
+     *
+     * @example
+     * const { slots } = await orita.getSlots('evt_abc123', '2026-08-01');
+     * // [{ label: "09:00 AM", value: "09:00" }, ...]
+     */
+    getSlots(eventTypeId: string, date: string): Promise<{
+        slots: Slot[];
+        date: string;
+        eventTypeId: string;
+    }>;
+    /**
+     * Book an appointment. Returns the created booking object.
+     *
+     * @example
+     * const booking = await orita.book({
+     *   eventTypeId: 'evt_abc123',
+     *   date: '2026-08-01',
+     *   time: '10:00',
+     *   clientName: 'Ana',
+     *   clientLastname: 'López',
+     *   clientEmail: 'ana@example.com',
+     * });
+     * console.log(booking.id); // "book_xyz789"
+     */
+    book(params: BookingParams): Promise<Booking>;
+    /**
+     * List your bookings with optional filtering.
+     *
+     * @example
+     * const bookings = await orita.getBookings({ status: 'confirmed' });
+     */
+    getBookings(params?: BookingsListParams): Promise<Booking[]>;
+    /**
+     * Retrieve a single booking by ID.
+     *
+     * @example
+     * const booking = await orita.getBooking('book_xyz789');
+     * console.log(booking.status); // "confirmed"
+     */
+    getBooking(bookingId: string): Promise<Booking>;
+    /**
+     * Cancel a booking by ID.
+     *
+     * @param bookingId - The booking ID to cancel
+     * @param reason - Optional cancellation reason
+     *
+     * @example
+     * const result = await orita.cancelBooking('book_xyz789', 'Client requested reschedule');
+     */
+    cancelBooking(bookingId: string, reason?: string): Promise<Booking>;
+    /**
+     * Get your own Capability Manifest (your profile).
+     * Requires authentication.
+     *
+     * @example
+     * const profile = await orita.getMyProfile();
+     * console.log(profile.username);
+     */
+    getMyProfile(): Promise<Profile>;
+    /**
+     * Update your profile fields.
+     *
+     * @example
+     * const updated = await orita.updateProfile({ bio: 'AI-native therapist' });
+     */
+    updateProfile(fields: UpdateProfileParams): Promise<Profile>;
+    /**
+     * Fetch the **public** Capability Manifest for any professional by username.
+     * No API key is needed for this request.
+     *
+     * @param username - The professional's username (e.g. "dra-martinez")
+     *
+     * @example
+     * const manifest = await orita.getProfile('dra-martinez');
+     * console.log(manifest.eventTypes);
+     */
+    getProfile(username: string): Promise<Profile>;
+}
+
+/**
+ * Base error class for all Orita API errors.
+ */
+declare class OritaError extends Error {
+    readonly statusCode?: number;
+    readonly response?: unknown;
+    constructor(message: string, statusCode?: number, response?: unknown);
+}
+/**
+ * Thrown when the API key is invalid or missing (HTTP 401).
+ */
+declare class OritaAuthError extends OritaError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Thrown when the requested resource is not found (HTTP 404).
+ */
+declare class OritaNotFoundError extends OritaError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Thrown when the requested time slot is already taken (HTTP 409).
+ */
+declare class OritaSlotUnavailableError extends OritaError {
+    constructor(message?: string, response?: unknown);
+}
+
+export { type Booking, type BookingParams, type BookingsListParams, type EventType, OritaAuthError, OritaClient, type OritaClientOptions, OritaError, OritaNotFoundError, OritaSlotUnavailableError, type Profile, type Slot, type SlotsResponse, type UpdateProfileParams };

package/dist/index.d.ts

@@ -0,0 +1,202 @@
+interface EventType {
+    id: string;
+    title: string;
+    slug: string;
+    duration: number;
+    description?: string;
+    location?: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Slot {
+    label: string;
+    value: string;
+}
+interface SlotsResponse {
+    slots: Slot[];
+    date: string;
+    eventTypeId: string;
+}
+interface Booking {
+    id: string;
+    eventTypeId: string;
+    date: string;
+    time: string;
+    status: 'confirmed' | 'cancelled' | 'completed' | 'pending';
+    clientName: string;
+    clientLastname: string;
+    clientEmail: string;
+    clientPhone?: string;
+    clientTimezone?: string;
+    notes?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface BookingParams {
+    eventTypeId: string;
+    date: string;
+    time: string;
+    clientName: string;
+    clientLastname: string;
+    clientEmail: string;
+    clientPhone?: string;
+    clientTimezone?: string;
+    notes?: string;
+}
+interface BookingsListParams {
+    page?: number;
+    limit?: number;
+    status?: 'confirmed' | 'cancelled' | 'completed' | 'pending';
+}
+interface Profile {
+    username: string;
+    bio?: string;
+    timezone?: string;
+    eventTypes: EventType[];
+    [key: string]: unknown;
+}
+interface UpdateProfileParams {
+    bio?: string;
+    timezone?: string;
+    [key: string]: unknown;
+}
+
+interface OritaClientOptions {
+    /**
+     * Your Orita API key (must start with `orita_`).
+     * Get yours at https://orita.online/developers
+     */
+    apiKey: string;
+    /**
+     * Override the base URL (for self-hosted or staging environments).
+     * @default "https://orita.online/api/v1"
+     */
+    baseUrl?: string;
+}
+declare class OritaClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(options: OritaClientOptions);
+    private buildUrl;
+    private request;
+    /**
+     * List all active event types for your account.
+     *
+     * @example
+     * const eventTypes = await orita.getEventTypes();
+     * // [{ id: "evt_abc123", title: "Initial Consultation", duration: 30, ... }]
+     */
+    getEventTypes(): Promise<EventType[]>;
+    /**
+     * Get available time slots for an event type on a given date.
+     *
+     * @param eventTypeId - Event type ID from `getEventTypes()`
+     * @param date - Date in `YYYY-MM-DD` format
+     *
+     * @example
+     * const { slots } = await orita.getSlots('evt_abc123', '2026-08-01');
+     * // [{ label: "09:00 AM", value: "09:00" }, ...]
+     */
+    getSlots(eventTypeId: string, date: string): Promise<{
+        slots: Slot[];
+        date: string;
+        eventTypeId: string;
+    }>;
+    /**
+     * Book an appointment. Returns the created booking object.
+     *
+     * @example
+     * const booking = await orita.book({
+     *   eventTypeId: 'evt_abc123',
+     *   date: '2026-08-01',
+     *   time: '10:00',
+     *   clientName: 'Ana',
+     *   clientLastname: 'López',
+     *   clientEmail: 'ana@example.com',
+     * });
+     * console.log(booking.id); // "book_xyz789"
+     */
+    book(params: BookingParams): Promise<Booking>;
+    /**
+     * List your bookings with optional filtering.
+     *
+     * @example
+     * const bookings = await orita.getBookings({ status: 'confirmed' });
+     */
+    getBookings(params?: BookingsListParams): Promise<Booking[]>;
+    /**
+     * Retrieve a single booking by ID.
+     *
+     * @example
+     * const booking = await orita.getBooking('book_xyz789');
+     * console.log(booking.status); // "confirmed"
+     */
+    getBooking(bookingId: string): Promise<Booking>;
+    /**
+     * Cancel a booking by ID.
+     *
+     * @param bookingId - The booking ID to cancel
+     * @param reason - Optional cancellation reason
+     *
+     * @example
+     * const result = await orita.cancelBooking('book_xyz789', 'Client requested reschedule');
+     */
+    cancelBooking(bookingId: string, reason?: string): Promise<Booking>;
+    /**
+     * Get your own Capability Manifest (your profile).
+     * Requires authentication.
+     *
+     * @example
+     * const profile = await orita.getMyProfile();
+     * console.log(profile.username);
+     */
+    getMyProfile(): Promise<Profile>;
+    /**
+     * Update your profile fields.
+     *
+     * @example
+     * const updated = await orita.updateProfile({ bio: 'AI-native therapist' });
+     */
+    updateProfile(fields: UpdateProfileParams): Promise<Profile>;
+    /**
+     * Fetch the **public** Capability Manifest for any professional by username.
+     * No API key is needed for this request.
+     *
+     * @param username - The professional's username (e.g. "dra-martinez")
+     *
+     * @example
+     * const manifest = await orita.getProfile('dra-martinez');
+     * console.log(manifest.eventTypes);
+     */
+    getProfile(username: string): Promise<Profile>;
+}
+
+/**
+ * Base error class for all Orita API errors.
+ */
+declare class OritaError extends Error {
+    readonly statusCode?: number;
+    readonly response?: unknown;
+    constructor(message: string, statusCode?: number, response?: unknown);
+}
+/**
+ * Thrown when the API key is invalid or missing (HTTP 401).
+ */
+declare class OritaAuthError extends OritaError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Thrown when the requested resource is not found (HTTP 404).
+ */
+declare class OritaNotFoundError extends OritaError {
+    constructor(message?: string, response?: unknown);
+}
+/**
+ * Thrown when the requested time slot is already taken (HTTP 409).
+ */
+declare class OritaSlotUnavailableError extends OritaError {
+    constructor(message?: string, response?: unknown);
+}
+
+export { type Booking, type BookingParams, type BookingsListParams, type EventType, OritaAuthError, OritaClient, type OritaClientOptions, OritaError, OritaNotFoundError, OritaSlotUnavailableError, type Profile, type Slot, type SlotsResponse, type UpdateProfileParams };