@withaevum/sdk 0.0.1

package/dist/availability.d.ts

@@ -0,0 +1,39 @@
+import { AevumClient } from './client';
+import type { GetSlotsParams, GetSlotsResponse, CheckAvailabilityParams, CheckAvailabilityResponse, GetAvailabilitySchedulesParams, CreateAvailabilityScheduleParams, UpdateAvailabilityScheduleParams, AvailabilitySchedule, GetAvailabilitySlotsParams } from './types';
+/**
+ * Availability API methods
+ */
+export declare class AvailabilityAPI {
+    private client;
+    constructor(client: AevumClient);
+    /**
+     * Get available time slots for a provider within a date range
+     * Enhanced version that supports offeringId and limit
+     */
+    getSlots(params: GetSlotsParams | GetAvailabilitySlotsParams): Promise<GetSlotsResponse>;
+    /**
+     * Get availability schedules
+     */
+    getSchedules(params?: GetAvailabilitySchedulesParams): Promise<AvailabilitySchedule[]>;
+    /**
+     * Create an availability schedule for a provider
+     */
+    createSchedule(params: CreateAvailabilityScheduleParams): Promise<AvailabilitySchedule>;
+    /**
+     * Get a single availability schedule by ID
+     */
+    getSchedule(scheduleId: string): Promise<AvailabilitySchedule>;
+    /**
+     * Update an availability schedule (partial update)
+     */
+    updateSchedule(scheduleId: string, params: UpdateAvailabilityScheduleParams): Promise<AvailabilitySchedule>;
+    /**
+     * Delete an availability schedule
+     */
+    deleteSchedule(scheduleId: string): Promise<void>;
+    /**
+     * Check if a specific time slot is available
+     * This is a client-side implementation that uses getSlots()
+     */
+    check(params: CheckAvailabilityParams): Promise<CheckAvailabilityResponse>;
+}

package/dist/availability.js

@@ -0,0 +1,164 @@
+/**
+ * Availability API methods
+ */
+export class AvailabilityAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get available time slots for a provider within a date range
+     * Enhanced version that supports offeringId and limit
+     */
+    async getSlots(params) {
+        const query = {};
+        // Support both old and new parameter formats
+        if ('providerId' in params && params.providerId) {
+            query.providerId = params.providerId;
+        }
+        if ('offeringId' in params && params.offeringId) {
+            query.offeringId = params.offeringId;
+        }
+        if ('start' in params && params.start) {
+            query.start = params.start;
+        }
+        else if ('startDate' in params && params.startDate) {
+            query.start = params.startDate;
+        }
+        if ('end' in params && params.end) {
+            query.end = params.end;
+        }
+        else if ('endDate' in params && params.endDate) {
+            query.end = params.endDate;
+        }
+        if ('limit' in params && params.limit !== undefined) {
+            query.limit = params.limit;
+        }
+        // For backward compatibility with GetSlotsParams
+        if ('startDate' in params && 'endDate' in params) {
+            if (!params.startDate || !params.endDate) {
+                throw new Error('startDate and endDate are required');
+            }
+        }
+        else if (!query.start || !query.end) {
+            throw new Error('start/startDate and end/endDate are required');
+        }
+        try {
+            return await this.client.request('GET', '/api/v1/orgs/{orgId}/availability/slots', { query });
+        }
+        catch (error) {
+            // Handle 404 gracefully - endpoint might not exist yet
+            if (error?.status === 404 || error?.message?.includes('404')) {
+                console.warn('Availability slots endpoint not found, returning empty slots');
+                return { slots: [] };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get availability schedules
+     */
+    async getSchedules(params) {
+        const query = {};
+        if (params?.providerId) {
+            query.providerId = params.providerId;
+        }
+        try {
+            const response = await this.client.request('GET', '/api/v1/orgs/{orgId}/availability/schedules', { query });
+            return response || [];
+        }
+        catch (error) {
+            // Handle 404 gracefully - endpoint might not exist yet
+            if (error?.status === 404 || error?.message?.includes('404')) {
+                console.warn('Availability schedules endpoint not found, returning empty array');
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create an availability schedule for a provider
+     */
+    async createSchedule(params) {
+        return this.client.request('POST', '/api/v1/orgs/{orgId}/availability/schedules', {
+            body: {
+                providerId: params.providerId,
+                name: params.name,
+                timezone: params.timezone,
+                weekly_hours: params.weekly_hours,
+                recurrence_preset: params.recurrence_preset,
+                recurrence_end_mode: params.recurrence_end_mode,
+                recurrence_end_date: params.recurrence_end_date,
+                recurrence_end_count: params.recurrence_end_count,
+            },
+        });
+    }
+    /**
+     * Get a single availability schedule by ID
+     */
+    async getSchedule(scheduleId) {
+        return this.client.request('GET', `/api/v1/orgs/{orgId}/availability/schedules/${scheduleId}`);
+    }
+    /**
+     * Update an availability schedule (partial update)
+     */
+    async updateSchedule(scheduleId, params) {
+        const body = {};
+        if (params.name !== undefined)
+            body.name = params.name;
+        if (params.timezone !== undefined)
+            body.timezone = params.timezone;
+        if (params.weekly_hours !== undefined)
+            body.weekly_hours = params.weekly_hours;
+        if (params.recurrence_preset !== undefined)
+            body.recurrence_preset = params.recurrence_preset;
+        if (params.recurrence_end_mode !== undefined)
+            body.recurrence_end_mode = params.recurrence_end_mode;
+        if (params.recurrence_end_date !== undefined)
+            body.recurrence_end_date = params.recurrence_end_date;
+        if (params.recurrence_end_count !== undefined)
+            body.recurrence_end_count = params.recurrence_end_count;
+        return this.client.request('PATCH', `/api/v1/orgs/{orgId}/availability/schedules/${scheduleId}`, { body });
+    }
+    /**
+     * Delete an availability schedule
+     */
+    async deleteSchedule(scheduleId) {
+        await this.client.request('DELETE', `/api/v1/orgs/{orgId}/availability/schedules/${scheduleId}`);
+    }
+    /**
+     * Check if a specific time slot is available
+     * This is a client-side implementation that uses getSlots()
+     */
+    async check(params) {
+        const { providerId, startTime, duration } = params;
+        // Parse start time
+        const start = new Date(startTime);
+        if (isNaN(start.getTime())) {
+            throw new Error('Invalid startTime format. Expected ISO 8601 datetime with timezone');
+        }
+        // Calculate end time
+        const end = new Date(start.getTime() + duration * 60 * 1000);
+        // Get slots for a window around the requested time (1 day before and after)
+        const windowStart = new Date(start.getTime() - 24 * 60 * 60 * 1000);
+        const windowEnd = new Date(end.getTime() + 24 * 60 * 60 * 1000);
+        // Format as ISO strings with timezone
+        const startDate = windowStart.toISOString();
+        const endDate = windowEnd.toISOString();
+        // Get available slots
+        const { slots } = await this.getSlots({
+            providerId,
+            startDate,
+            endDate,
+        });
+        // Check if requested time falls within any available slot
+        const requestedStart = start.getTime();
+        const requestedEnd = end.getTime();
+        const isAvailable = slots.some((slot) => {
+            const slotStart = new Date(slot.start_time_utc).getTime();
+            const slotEnd = new Date(slot.end_time_utc).getTime();
+            // Check if requested time is completely within the slot
+            return requestedStart >= slotStart && requestedEnd <= slotEnd;
+        });
+        return { available: isAvailable };
+    }
+}

package/dist/bookings.d.ts

@@ -0,0 +1,42 @@
+import { AevumClient } from './client';
+import type { Booking, CreateBookingParams, ListBookingsParams, ListBookingsResponse, RescheduleBookingParams } from './types';
+/**
+ * Bookings API methods
+ */
+export declare class BookingsAPI {
+    private client;
+    constructor(client: AevumClient);
+    /**
+     * Create a new booking
+     */
+    create(params: CreateBookingParams): Promise<Booking>;
+    /**
+     * Get a booking by ID
+     */
+    get(bookingId: string): Promise<Booking>;
+    /**
+     * List bookings with optional filters
+     */
+    list(params?: ListBookingsParams): Promise<ListBookingsResponse>;
+    /**
+     * Cancel a booking
+     */
+    cancel(bookingId: string, reason?: string): Promise<Booking>;
+    /**
+     * Reschedule a booking
+     */
+    reschedule(bookingId: string, params: RescheduleBookingParams): Promise<Booking>;
+    /**
+     * Confirm a booking
+     */
+    confirm(bookingId: string, params?: {
+        sendNotification?: boolean;
+    }): Promise<Booking>;
+    /**
+     * Update a booking (status and/or notes)
+     */
+    update(bookingId: string, params: {
+        status?: string;
+        notes?: string;
+    }): Promise<Booking>;
+}

package/dist/bookings.js

@@ -0,0 +1,148 @@
+/**
+ * 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);
+    }
+    /**
+     * Confirm a booking
+     */
+    async confirm(bookingId, params) {
+        const body = {
+            sendNotification: params?.sendNotification ?? false,
+        };
+        await this.client.request('PATCH', `/api/v1/orgs/{orgId}/bookings/${bookingId}/confirm`, { body });
+        // Return updated booking
+        return this.get(bookingId);
+    }
+    /**
+     * Update a booking (status and/or notes)
+     */
+    async update(bookingId, params) {
+        const body = {};
+        if (params.status !== undefined) {
+            body.status = params.status;
+        }
+        if (params.notes !== undefined) {
+            body.notes = params.notes;
+        }
+        await this.client.request('PATCH', `/api/v1/orgs/{orgId}/bookings/${bookingId}`, { 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,44 @@
+import { AvailabilityAPI } from './availability';
+import { BookingsAPI } from './bookings';
+import { OfferingsAPI } from './offerings';
+import { CustomersAPI } from './customers';
+import { ProvidersAPI } from './providers';
+import { OrgsAPI } from './orgs';
+import { CalendarAPI } from './calendar';
+import { AnalyticsAPI } from './analytics';
+import { PaymentsAPI } from './payments';
+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 orgs: OrgsAPI;
+    readonly calendar: CalendarAPI;
+    readonly analytics: AnalyticsAPI;
+    readonly payments: PaymentsAPI;
+    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,162 @@
+// 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 { OrgsAPI } from './orgs';
+import { CalendarAPI } from './calendar';
+import { AnalyticsAPI } from './analytics';
+import { PaymentsAPI } from './payments';
+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;
+        // Default baseUrl: use provided, or check env var (Node.js only), or use production
+        if (config.baseUrl) {
+            this.baseUrl = config.baseUrl;
+        }
+        else if (typeof process !== 'undefined' && process.env?.AEVUM_API_BASE_URL) {
+            // Check environment variable if in Node.js
+            this.baseUrl = process.env.AEVUM_API_BASE_URL;
+        }
+        else if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') {
+            // Default to localhost in development
+            this.baseUrl = 'http://localhost:3000';
+        }
+        else {
+            // Production default
+            this.baseUrl = 'https://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.orgs = new OrgsAPI(this);
+        this.calendar = new CalendarAPI(this);
+        this.analytics = new AnalyticsAPI(this);
+        this.payments = new PaymentsAPI(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) {
+            // Safely extract error data, handling null/undefined cases
+            const errorData = (data && typeof data === 'object') ? data : null;
+            const errorMessage = errorData?.error || `API request failed with status ${response.status}`;
+            const errorCode = errorData?.code;
+            const errorIssues = errorData?.issues;
+            if (response.status === 401 || response.status === 403) {
+                throw new AevumAuthenticationError(errorMessage, response.status);
+            }
+            if (response.status === 404) {
+                throw new AevumNotFoundError(errorMessage);
+            }
+            if (response.status === 400) {
+                throw new AevumValidationError(errorMessage, errorIssues);
+            }
+            throw new AevumAPIError(errorMessage, response.status, errorCode, errorIssues);
+        }
+        return data;
+    }
+}