@withaevum/sdk 1.0.0

package/dist/bookings.js

@@ -0,0 +1,122 @@
+/**
+ * Bookings API methods
+ */
+export class BookingsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Create a new booking
+     */
+    async create(params) {
+        // Map SDK params to API format
+        const providerIds = params.providerIds || (params.providerId ? [params.providerId] : []);
+        const offeringIds = params.offeringIds || (params.offeringId ? [params.offeringId] : []);
+        if (providerIds.length === 0) {
+            throw new Error('At least one providerId or providerIds is required');
+        }
+        if (offeringIds.length === 0) {
+            throw new Error('At least one offeringId or offeringIds is required');
+        }
+        // Calculate endTime if not provided (assuming we can infer from offering duration)
+        // For now, require endTime to be provided
+        if (!params.endTime) {
+            throw new Error('endTime is required');
+        }
+        // Build request body
+        const body = {
+            providerIds,
+            offeringIds,
+            start_time: params.startTime,
+            end_time: params.endTime,
+            kind: params.kind || 'standard',
+            status: params.status || 'pending',
+        };
+        // Handle customer
+        if (params.customerId) {
+            body.customerId = params.customerId;
+        }
+        else if (params.customerEmail || params.customer) {
+            body.customer = {
+                email: params.customerEmail || params.customer?.email,
+                name: params.customer?.name,
+                phone: params.customer?.phone,
+            };
+        }
+        else {
+            throw new Error('Either customerId, customerEmail, or customer object is required');
+        }
+        // Add optional fields
+        if (params.price_cents !== undefined) {
+            body.price_cents = params.price_cents;
+        }
+        if (params.notes) {
+            body.notes = params.notes;
+        }
+        const response = await this.client.request('POST', '/api/v1/orgs/{orgId}/bookings', { body });
+        // The API returns a partial booking, so we need to fetch the full booking
+        if (response.id) {
+            return this.get(response.id);
+        }
+        return response;
+    }
+    /**
+     * Get a booking by ID
+     */
+    async get(bookingId) {
+        return this.client.request('GET', `/api/v1/orgs/{orgId}/bookings/${bookingId}`);
+    }
+    /**
+     * List bookings with optional filters
+     */
+    async list(params) {
+        const query = {};
+        if (params?.status) {
+            query.status = params.status;
+        }
+        if (params?.providerId) {
+            query.providerId = params.providerId;
+        }
+        if (params?.customerId) {
+            query.customerId = params.customerId;
+        }
+        if (params?.startDate) {
+            query.start = params.startDate;
+        }
+        if (params?.endDate) {
+            query.end = params.endDate;
+        }
+        if (params?.page !== undefined) {
+            query.page = params.page;
+        }
+        if (params?.pageSize !== undefined) {
+            query.pageSize = params.pageSize;
+        }
+        return this.client.request('GET', '/api/v1/orgs/{orgId}/bookings', { query });
+    }
+    /**
+     * Cancel a booking
+     */
+    async cancel(bookingId, reason) {
+        const body = {};
+        if (reason) {
+            body.reason = reason;
+        }
+        await this.client.request('PATCH', `/api/v1/orgs/{orgId}/bookings/${bookingId}/cancel`, { body });
+        // Return updated booking
+        return this.get(bookingId);
+    }
+    /**
+     * Reschedule a booking
+     */
+    async reschedule(bookingId, params) {
+        const body = {
+            start_time: params.start_time,
+            end_time: params.end_time,
+            sendNotification: params.sendNotification ?? false,
+        };
+        await this.client.request('PATCH', `/api/v1/orgs/{orgId}/bookings/${bookingId}/reschedule`, { body });
+        // Return updated booking
+        return this.get(bookingId);
+    }
+}

package/dist/calendar.d.ts

@@ -0,0 +1,13 @@
+import { AevumClient } from './client';
+import type { GetCalendarEventsParams, GetCalendarEventsResponse } from './types';
+/**
+ * Calendar API methods
+ */
+export declare class CalendarAPI {
+    private client;
+    constructor(client: AevumClient);
+    /**
+     * Get calendar events (bookings and events) for a date range
+     */
+    getEvents(params?: GetCalendarEventsParams): Promise<GetCalendarEventsResponse>;
+}

package/dist/calendar.js

@@ -0,0 +1,65 @@
+/**
+ * Calendar API methods
+ */
+export class CalendarAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get calendar events (bookings and events) for a date range
+     */
+    async getEvents(params) {
+        const orgId = await this.client.resolveOrgId();
+        // Get bookings for calendar
+        const bookingsQuery = {};
+        if (params?.providerId) {
+            bookingsQuery.providerId = params.providerId;
+        }
+        if (params?.start) {
+            bookingsQuery.start = params.start;
+        }
+        if (params?.end) {
+            bookingsQuery.end = params.end;
+        }
+        const bookings = await this.client.request('GET', '/api/v1/orgs/{orgId}/bookings', {
+            query: bookingsQuery,
+        });
+        // Get events for calendar
+        const eventsQuery = {};
+        if (params?.providerId) {
+            eventsQuery.providerId = params.providerId;
+        }
+        if (params?.start) {
+            eventsQuery.start = params.start;
+        }
+        if (params?.end) {
+            eventsQuery.end = params.end;
+        }
+        let events = [];
+        try {
+            const eventsResponse = await this.client.request('GET', `/api/v1/orgs/${orgId}/events`, { query: eventsQuery });
+            // Handle paginated response - extract events/offerings array
+            if (Array.isArray(eventsResponse)) {
+                events = eventsResponse;
+            }
+            else if (eventsResponse?.events) {
+                events = eventsResponse.events;
+            }
+            else if (eventsResponse?.offerings) {
+                // Events endpoint returns 'offerings' property
+                events = eventsResponse.offerings;
+            }
+            else {
+                events = [];
+            }
+        }
+        catch (error) {
+            // Events endpoint might not be available, continue without it
+            console.warn('Failed to fetch events:', error);
+        }
+        return {
+            bookings: bookings.bookings || [],
+            events: events || [],
+        };
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,40 @@
+import { AvailabilityAPI } from './availability';
+import { BookingsAPI } from './bookings';
+import { OfferingsAPI } from './offerings';
+import { CustomersAPI } from './customers';
+import { ProvidersAPI } from './providers';
+import { CalendarAPI } from './calendar';
+import { AnalyticsAPI } from './analytics';
+import type { AevumClientConfig } from './types';
+/**
+ * Main client class for interacting with the Aevum API
+ */
+export declare class AevumClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private orgId;
+    private orgIdPromise;
+    readonly bookings: BookingsAPI;
+    readonly availability: AvailabilityAPI;
+    readonly offerings: OfferingsAPI;
+    readonly customers: CustomersAPI;
+    readonly providers: ProvidersAPI;
+    readonly calendar: CalendarAPI;
+    readonly analytics: AnalyticsAPI;
+    constructor(config: AevumClientConfig);
+    /**
+     * Resolve organization ID from API key (cached after first call)
+     */
+    resolveOrgId(): Promise<string>;
+    /**
+     * Internal method to fetch orgId from API
+     */
+    private _fetchOrgId;
+    /**
+     * Make an authenticated HTTP request to the API
+     */
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        query?: Record<string, string | number | undefined>;
+    }): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,139 @@
+// packages/sdk/src/client.ts
+import { AvailabilityAPI } from './availability';
+import { BookingsAPI } from './bookings';
+import { OfferingsAPI } from './offerings';
+import { CustomersAPI } from './customers';
+import { ProvidersAPI } from './providers';
+import { CalendarAPI } from './calendar';
+import { AnalyticsAPI } from './analytics';
+import { AevumAPIError, AevumAuthenticationError, AevumNotFoundError, AevumValidationError, } from './errors';
+/**
+ * Main client class for interacting with the Aevum API
+ */
+export class AevumClient {
+    constructor(config) {
+        this.orgId = null;
+        this.orgIdPromise = null;
+        if (!config.apiKey) {
+            throw new Error('API key is required');
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://api.withaevum.com';
+        // Set orgId if provided in config (avoids extra API call)
+        if (config.orgId) {
+            this.orgId = config.orgId;
+        }
+        // Initialize API namespaces
+        this.bookings = new BookingsAPI(this);
+        this.availability = new AvailabilityAPI(this);
+        this.offerings = new OfferingsAPI(this);
+        this.customers = new CustomersAPI(this);
+        this.providers = new ProvidersAPI(this);
+        this.calendar = new CalendarAPI(this);
+        this.analytics = new AnalyticsAPI(this);
+    }
+    /**
+     * Resolve organization ID from API key (cached after first call)
+     */
+    async resolveOrgId() {
+        // Return cached orgId if available
+        if (this.orgId) {
+            return this.orgId;
+        }
+        // Return existing promise if resolution is in progress
+        if (this.orgIdPromise) {
+            return this.orgIdPromise;
+        }
+        // Start resolution
+        this.orgIdPromise = this._fetchOrgId();
+        this.orgId = await this.orgIdPromise;
+        return this.orgId;
+    }
+    /**
+     * Internal method to fetch orgId from API
+     */
+    async _fetchOrgId() {
+        const response = await fetch(`${this.baseUrl}/api/v1/session/org-from-key`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 401 || response.status === 403) {
+                throw new AevumAuthenticationError('Invalid or missing API key', response.status);
+            }
+            const errorText = await response.text().catch(() => '');
+            throw new AevumAPIError(`Failed to resolve organization ID: ${errorText}`, response.status);
+        }
+        const data = await response.json();
+        if (!data.orgId) {
+            throw new AevumAPIError('Invalid response: missing orgId', response.status);
+        }
+        return data.orgId;
+    }
+    /**
+     * Make an authenticated HTTP request to the API
+     */
+    async request(method, path, options = {}) {
+        // Ensure orgId is resolved (will use cache if already resolved)
+        const orgId = await this.resolveOrgId();
+        // Replace {orgId} placeholder in path if present
+        const resolvedPath = path.replace('{orgId}', orgId);
+        // Build URL with query parameters
+        const url = new URL(resolvedPath, this.baseUrl);
+        if (options.query) {
+            Object.entries(options.query).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, String(value));
+                }
+            });
+        }
+        // Prepare headers
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+        // Prepare request options
+        const requestOptions = {
+            method,
+            headers,
+        };
+        // Add body if present
+        if (options.body !== undefined) {
+            requestOptions.body = JSON.stringify(options.body);
+        }
+        // Make the request
+        const response = await fetch(url.toString(), requestOptions);
+        // Handle empty responses (204 No Content)
+        if (response.status === 204 ||
+            response.headers.get('content-length') === '0') {
+            return null;
+        }
+        // Parse response body
+        const text = await response.text();
+        let data;
+        try {
+            data = text ? JSON.parse(text) : null;
+        }
+        catch (error) {
+            throw new AevumAPIError(`Invalid JSON response: ${text}`, response.status);
+        }
+        // Handle errors
+        if (!response.ok) {
+            const errorData = data;
+            if (response.status === 401 || response.status === 403) {
+                throw new AevumAuthenticationError(errorData.error || 'Authentication failed', response.status);
+            }
+            if (response.status === 404) {
+                throw new AevumNotFoundError(errorData.error || 'Resource not found');
+            }
+            if (response.status === 400) {
+                throw new AevumValidationError(errorData.error || 'Validation error', errorData.issues);
+            }
+            throw new AevumAPIError(errorData.error || `API request failed with status ${response.status}`, response.status, errorData.code, errorData.issues);
+        }
+        return data;
+    }
+}

package/dist/customers.d.ts

@@ -0,0 +1,25 @@
+import { AevumClient } from './client';
+import type { Customer, CreateCustomerParams, ListCustomersParams, ListCustomersResponse, CustomerHistoryResponse } from './types';
+/**
+ * Customers API methods
+ */
+export declare class CustomersAPI {
+    private client;
+    constructor(client: AevumClient);
+    /**
+     * List customers for the organization
+     */
+    list(params?: ListCustomersParams): Promise<ListCustomersResponse>;
+    /**
+     * Get a single customer by ID
+     */
+    get(customerId: string): Promise<Customer>;
+    /**
+     * Create a new customer (or merge if email exists)
+     */
+    create(params: CreateCustomerParams): Promise<Customer>;
+    /**
+     * Get customer booking history with analytics
+     */
+    getHistory(customerId: string): Promise<CustomerHistoryResponse>;
+}

package/dist/customers.js

@@ -0,0 +1,60 @@
+/**
+ * Customers API methods
+ */
+export class CustomersAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List customers for the organization
+     */
+    async list(params) {
+        const query = {};
+        if (params?.q) {
+            query.q = params.q;
+        }
+        if (params?.providerId) {
+            query.providerId = params.providerId;
+        }
+        if (params?.page !== undefined) {
+            query.page = params.page;
+        }
+        if (params?.pageSize !== undefined) {
+            query.pageSize = params.pageSize;
+        }
+        return this.client.request('GET', '/api/v1/orgs/{orgId}/customers', { query });
+    }
+    /**
+     * Get a single customer by ID
+     */
+    async get(customerId) {
+        const response = await this.client.request('GET', `/api/v1/orgs/{orgId}/customers/${customerId}`);
+        return response.customer;
+    }
+    /**
+     * Create a new customer (or merge if email exists)
+     */
+    async create(params) {
+        const body = {};
+        if (params.name !== undefined) {
+            body.name = params.name;
+        }
+        if (params.email !== undefined) {
+            body.email = params.email;
+        }
+        if (params.phone !== undefined) {
+            body.phone = params.phone;
+        }
+        if (params.userId !== undefined) {
+            body.userId = params.userId;
+        }
+        const response = await this.client.request('POST', '/api/v1/orgs/{orgId}/customers', { body });
+        return response.customer;
+    }
+    /**
+     * Get customer booking history with analytics
+     */
+    async getHistory(customerId) {
+        return this.client.request('GET', `/api/v1/orgs/{orgId}/customers/${customerId}/history`);
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Base error class for all Aevum SDK errors
+ */
+export declare class AevumError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an API request fails
+ */
+export declare class AevumAPIError extends AevumError {
+    readonly status: number;
+    readonly code?: string;
+    readonly issues?: Array<{
+        path: string[];
+        message: string;
+    }>;
+    constructor(message: string, status: number, code?: string, issues?: Array<{
+        path: string[];
+        message: string;
+    }>);
+}
+/**
+ * Error thrown for authentication failures (401, 403)
+ */
+export declare class AevumAuthenticationError extends AevumAPIError {
+    constructor(message: string, status?: number);
+}
+/**
+ * Error thrown for validation errors (400)
+ */
+export declare class AevumValidationError extends AevumAPIError {
+    constructor(message: string, issues?: Array<{
+        path: string[];
+        message: string;
+    }>);
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+export declare class AevumNotFoundError extends AevumAPIError {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,54 @@
+// packages/sdk/src/errors.ts
+/**
+ * Base error class for all Aevum SDK errors
+ */
+export class AevumError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AevumError';
+        Object.setPrototypeOf(this, AevumError.prototype);
+    }
+}
+/**
+ * Error thrown when an API request fails
+ */
+export class AevumAPIError extends AevumError {
+    constructor(message, status, code, issues) {
+        super(message);
+        this.name = 'AevumAPIError';
+        this.status = status;
+        this.code = code;
+        this.issues = issues;
+        Object.setPrototypeOf(this, AevumAPIError.prototype);
+    }
+}
+/**
+ * Error thrown for authentication failures (401, 403)
+ */
+export class AevumAuthenticationError extends AevumAPIError {
+    constructor(message, status = 401) {
+        super(message, status);
+        this.name = 'AevumAuthenticationError';
+        Object.setPrototypeOf(this, AevumAuthenticationError.prototype);
+    }
+}
+/**
+ * Error thrown for validation errors (400)
+ */
+export class AevumValidationError extends AevumAPIError {
+    constructor(message, issues) {
+        super(message, 400, 'validation_error', issues);
+        this.name = 'AevumValidationError';
+        Object.setPrototypeOf(this, AevumValidationError.prototype);
+    }
+}
+/**
+ * Error thrown when a resource is not found (404)
+ */
+export class AevumNotFoundError extends AevumAPIError {
+    constructor(message = 'Resource not found') {
+        super(message, 404, 'not_found');
+        this.name = 'AevumNotFoundError';
+        Object.setPrototypeOf(this, AevumNotFoundError.prototype);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { AevumClient } from './client';
+export { BookingsAPI } from './bookings';
+export { OfferingsAPI } from './offerings';
+export { CustomersAPI } from './customers';
+export { ProvidersAPI } from './providers';
+export { CalendarAPI } from './calendar';
+export { AnalyticsAPI } from './analytics';
+export { AvailabilityAPI } from './availability';
+export * from './types';
+export * from './errors';

package/dist/index.js

@@ -0,0 +1,11 @@
+// packages/sdk/src/index.ts
+export { AevumClient } from './client';
+export { BookingsAPI } from './bookings';
+export { OfferingsAPI } from './offerings';
+export { CustomersAPI } from './customers';
+export { ProvidersAPI } from './providers';
+export { CalendarAPI } from './calendar';
+export { AnalyticsAPI } from './analytics';
+export { AvailabilityAPI } from './availability';
+export * from './types';
+export * from './errors';

package/dist/offerings.d.ts

@@ -0,0 +1,99 @@
+import { AevumClient } from './client';
+import type { Offering, CreateOfferingParams, ListOfferingsParams, CreateSimpleOfferingParams, CreateRecurringWeeklyOfferingParams, CreateRecurringDailyOfferingParams, CreateSimpleOfferingEndpointParams } from './types';
+/**
+ * Offerings API methods
+ */
+export declare class OfferingsAPI {
+    private client;
+    constructor(client: AevumClient);
+    /**
+     * List offerings for the organization
+     */
+    list(params?: ListOfferingsParams): Promise<Offering[]>;
+    /**
+     * Get a single offering by ID
+     */
+    get(offeringId: string): Promise<Offering>;
+    /**
+     * Create a new offering
+     */
+    create(params: CreateOfferingParams): Promise<Offering>;
+    /**
+     * Create a simple offering (basic 1:1 offering using provider availability schedules)
+     * This is the simplest way to create an offering - it uses provider availability
+     * instead of fixed times or recurrence patterns.
+     *
+     * @example
+     * ```typescript
+     * const offering = await client.offerings.createSimple({
+     *   name: 'Therapy Session',
+     *   duration_minutes: 60,
+     *   price_cents: 15000,
+     *   description: 'One-on-one therapy session',
+     *   providerIds: [providerId]
+     * });
+     * ```
+     */
+    createSimple(params: CreateSimpleOfferingParams): Promise<Offering>;
+    /**
+     * Create a weekly recurring offering with specific days and time slots
+     *
+     * @example
+     * ```typescript
+     * const offering = await client.offerings.createRecurringWeekly({
+     *   name: 'Weekly Therapy',
+     *   duration_minutes: 60,
+     *   days: ['monday', 'wednesday', 'friday'],
+     *   timeSlots: [{ start: '09:00', end: '17:00' }],
+     *   price_cents: 15000,
+     *   providerIds: [providerId]
+     * });
+     * ```
+     */
+    createRecurringWeekly(params: CreateRecurringWeeklyOfferingParams): Promise<Offering>;
+    /**
+     * Create a daily recurring offering with time slots
+     *
+     * @example
+     * ```typescript
+     * const offering = await client.offerings.createRecurringDaily({
+     *   name: 'Daily Consultation',
+     *   duration_minutes: 30,
+     *   timeSlots: [
+     *     { start: '09:00', end: '12:00' },
+     *     { start: '14:00', end: '17:00' }
+     *   ],
+     *   price_cents: 5000,
+     *   providerIds: [providerId]
+     * });
+     * ```
+     */
+    createRecurringDaily(params: CreateRecurringDailyOfferingParams): Promise<Offering>;
+    /**
+     * Create an offering using the simplified endpoint
+     * This method calls the /simple endpoint which provides preset-based configuration
+     *
+     * @example
+     * ```typescript
+     * // Simple 1:1 offering
+     * const offering = await client.offerings.createFromSimple({
+     *   name: 'Therapy Session',
+     *   duration_minutes: 60,
+     *   price_cents: 15000,
+     *   preset: 'simple_1on1',
+     *   provider_ids: [providerId]
+     * });
+     *
+     * // Weekly recurring
+     * const weeklyOffering = await client.offerings.createFromSimple({
+     *   name: 'Weekly Therapy',
+     *   duration_minutes: 60,
+     *   preset: 'recurring_weekly',
+     *   weekly_days: ['monday', 'wednesday'],
+     *   weekly_time_slots: [{ start: '09:00', end: '17:00' }],
+     *   price_cents: 15000,
+     * });
+     * ```
+     */
+    createFromSimple(params: CreateSimpleOfferingEndpointParams): Promise<Offering>;
+}