@withaevum/sdk 1.0.0

package/dist/offerings.js

@@ -0,0 +1,355 @@
+/**
+ * Helper function to normalize day names
+ * Converts various formats (monday, MO, Monday) to standard weekday names
+ */
+function normalizeDayName(day) {
+    const normalized = day.toLowerCase().trim();
+    const dayMap = {
+        'sunday': 'sunday',
+        'sun': 'sunday',
+        'su': 'sunday',
+        'monday': 'monday',
+        'mon': 'monday',
+        'mo': 'monday',
+        'tuesday': 'tuesday',
+        'tue': 'tuesday',
+        'tu': 'tuesday',
+        'wednesday': 'wednesday',
+        'wed': 'wednesday',
+        'we': 'wednesday',
+        'thursday': 'thursday',
+        'thu': 'thursday',
+        'th': 'thursday',
+        'friday': 'friday',
+        'fri': 'friday',
+        'fr': 'friday',
+        'saturday': 'saturday',
+        'sat': 'saturday',
+        'sa': 'saturday',
+    };
+    return dayMap[normalized] || normalized;
+}
+/**
+ * Helper function to convert day name to repeat_on format (MO, TU, WE, etc.)
+ */
+function dayToRepeatOn(day) {
+    const normalized = normalizeDayName(day);
+    const repeatOnMap = {
+        'sunday': 'SU',
+        'monday': 'MO',
+        'tuesday': 'TU',
+        'wednesday': 'WE',
+        'thursday': 'TH',
+        'friday': 'FR',
+        'saturday': 'SA',
+    };
+    return repeatOnMap[normalized] || normalized.toUpperCase();
+}
+/**
+ * Offerings API methods
+ */
+export class OfferingsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List offerings for the organization
+     */
+    async list(params) {
+        const query = {};
+        if (params?.eventId) {
+            query.eventId = params.eventId;
+        }
+        if (params?.providerId) {
+            query.providerId = params.providerId;
+        }
+        const response = await this.client.request('GET', '/api/v1/orgs/{orgId}/offerings', { query });
+        return response || [];
+    }
+    /**
+     * Get a single offering by ID
+     */
+    async get(offeringId) {
+        const response = await this.client.request('GET', `/api/v1/orgs/{orgId}/offerings/${offeringId}`);
+        return response.offering;
+    }
+    /**
+     * Create a new offering
+     */
+    async create(params) {
+        const body = {
+            name: params.name,
+        };
+        if (params.description !== undefined) {
+            body.description = params.description;
+        }
+        if (params.price_cents !== undefined) {
+            body.price_cents = params.price_cents;
+        }
+        if (params.duration_minutes !== undefined) {
+            body.duration_minutes = params.duration_minutes;
+        }
+        if (params.timezone) {
+            body.timezone = params.timezone;
+        }
+        if (params.is_all_day !== undefined) {
+            body.is_all_day = params.is_all_day;
+        }
+        if (params.attendee_mode) {
+            body.attendee_mode = params.attendee_mode;
+        }
+        if (params.attendee_limit !== undefined) {
+            body.attendee_limit = params.attendee_limit;
+        }
+        if (params.customer) {
+            body.customer = params.customer;
+        }
+        if (params.status) {
+            body.status = params.status;
+        }
+        if (params.type) {
+            body.type = params.type;
+        }
+        if (params.time_mode) {
+            body.time_mode = params.time_mode;
+        }
+        if (params.start_time) {
+            body.start_time = params.start_time;
+        }
+        if (params.end_time) {
+            body.end_time = params.end_time;
+        }
+        if (params.session_count !== undefined) {
+            body.session_count = params.session_count;
+        }
+        if (params.recurrence_preset !== undefined) {
+            body.recurrence_preset = params.recurrence_preset;
+        }
+        if (params.recurrence_interval_count !== undefined) {
+            body.recurrence_interval_count = params.recurrence_interval_count;
+        }
+        if (params.recurrence_interval_unit) {
+            body.recurrence_interval_unit = params.recurrence_interval_unit;
+        }
+        if (params.recurrence_repeat_on !== undefined) {
+            body.recurrence_repeat_on = params.recurrence_repeat_on;
+        }
+        if (params.recurrence_end_mode !== undefined) {
+            body.recurrence_end_mode = params.recurrence_end_mode;
+        }
+        if (params.recurrence_end_date) {
+            body.recurrence_end_date = params.recurrence_end_date;
+        }
+        if (params.recurrence_end_count !== undefined) {
+            body.recurrence_end_count = params.recurrence_end_count;
+        }
+        if (params.override_price_cents !== undefined) {
+            body.override_price_cents = params.override_price_cents;
+        }
+        if (params.min_age !== undefined) {
+            body.min_age = params.min_age;
+        }
+        if (params.max_age !== undefined) {
+            body.max_age = params.max_age;
+        }
+        if (params.window_start_time) {
+            body.window_start_time = params.window_start_time;
+        }
+        if (params.window_end_time) {
+            body.window_end_time = params.window_end_time;
+        }
+        if (params.cadence_minutes !== undefined) {
+            body.cadence_minutes = params.cadence_minutes;
+        }
+        if (params.slot_days) {
+            body.slot_days = params.slot_days;
+        }
+        if (params.providerIds && params.providerIds.length > 0) {
+            body.providerIds = params.providerIds;
+        }
+        if (params.hours !== undefined) {
+            body.hours = params.hours;
+        }
+        if (params.weekly_hours !== undefined) {
+            body.weekly_hours = params.weekly_hours;
+        }
+        if (params.monthly_recurrence !== undefined) {
+            body.monthly_recurrence = params.monthly_recurrence;
+        }
+        const response = await this.client.request('POST', '/api/v1/orgs/{orgId}/offerings', { body });
+        return response.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]
+     * });
+     * ```
+     */
+    async createSimple(params) {
+        return this.create({
+            name: params.name,
+            duration_minutes: params.duration_minutes,
+            price_cents: params.price_cents,
+            description: params.description,
+            timezone: params.timezone,
+            attendee_mode: '1:1',
+            is_all_day: false,
+            providerIds: params.providerIds,
+            // No recurrence_preset = uses provider availability schedules
+        });
+    }
+    /**
+     * 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]
+     * });
+     * ```
+     */
+    async createRecurringWeekly(params) {
+        // Normalize day names and build weekly_hours object
+        const weekly_hours = {
+            sunday: [],
+            monday: [],
+            tuesday: [],
+            wednesday: [],
+            thursday: [],
+            friday: [],
+            saturday: [],
+        };
+        // Map days to weekly_hours format
+        const normalizedDays = params.days.map(normalizeDayName);
+        normalizedDays.forEach((day) => {
+            if (weekly_hours[day] !== undefined) {
+                weekly_hours[day] = params.timeSlots;
+            }
+        });
+        // Build recurrence_repeat_on string (MO,WE,FR format)
+        const repeatOn = normalizedDays
+            .map(dayToRepeatOn)
+            .filter(Boolean)
+            .join(',');
+        return this.create({
+            name: params.name,
+            duration_minutes: params.duration_minutes,
+            price_cents: params.price_cents,
+            description: params.description,
+            timezone: params.timezone,
+            attendee_mode: '1:1',
+            is_all_day: false,
+            recurrence_preset: 'weekly',
+            recurrence_repeat_on: repeatOn,
+            weekly_hours,
+            providerIds: params.providerIds,
+        });
+    }
+    /**
+     * 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]
+     * });
+     * ```
+     */
+    async createRecurringDaily(params) {
+        return this.create({
+            name: params.name,
+            duration_minutes: params.duration_minutes,
+            price_cents: params.price_cents,
+            description: params.description,
+            timezone: params.timezone,
+            attendee_mode: '1:1',
+            is_all_day: false,
+            recurrence_preset: 'daily',
+            hours: params.timeSlots,
+            providerIds: params.providerIds,
+        });
+    }
+    /**
+     * 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,
+     * });
+     * ```
+     */
+    async createFromSimple(params) {
+        const body = {
+            name: params.name,
+            duration_minutes: params.duration_minutes,
+        };
+        if (params.description !== undefined) {
+            body.description = params.description;
+        }
+        if (params.price_cents !== undefined) {
+            body.price_cents = params.price_cents;
+        }
+        if (params.timezone) {
+            body.timezone = params.timezone;
+        }
+        if (params.provider_ids && params.provider_ids.length > 0) {
+            body.provider_ids = params.provider_ids;
+        }
+        if (params.preset) {
+            body.preset = params.preset;
+        }
+        if (params.weekly_days && params.weekly_days.length > 0) {
+            body.weekly_days = params.weekly_days;
+        }
+        if (params.weekly_time_slots && params.weekly_time_slots.length > 0) {
+            body.weekly_time_slots = params.weekly_time_slots;
+        }
+        if (params.daily_time_slots && params.daily_time_slots.length > 0) {
+            body.daily_time_slots = params.daily_time_slots;
+        }
+        if (params.attendee_limit !== undefined) {
+            body.attendee_limit = params.attendee_limit;
+        }
+        const response = await this.client.request('POST', '/api/v1/orgs/{orgId}/offerings/simple', { body });
+        return response.offering;
+    }
+}

package/dist/providers.d.ts

@@ -0,0 +1,21 @@
+import { AevumClient } from './client';
+import type { Provider, CreateProviderParams, ListProvidersParams } from './types';
+/**
+ * Providers API methods
+ */
+export declare class ProvidersAPI {
+    private client;
+    constructor(client: AevumClient);
+    /**
+     * List providers for the organization
+     */
+    list(params?: ListProvidersParams): Promise<Provider[]>;
+    /**
+     * Get a single provider by ID
+     */
+    get(providerId: string): Promise<Provider>;
+    /**
+     * Create a new provider
+     */
+    create(params: CreateProviderParams): Promise<Provider>;
+}

package/dist/providers.js

@@ -0,0 +1,58 @@
+/**
+ * Providers API methods
+ */
+export class ProvidersAPI {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List providers for the organization
+     */
+    async list(params) {
+        const query = {};
+        if (params?.query) {
+            query.search = params.query; // API uses 'search' not 'query'
+        }
+        if (params?.page !== undefined) {
+            query.page = params.page;
+        }
+        if (params?.pageSize !== undefined) {
+            query.pageSize = params.pageSize;
+        }
+        const response = await this.client.request('GET', '/api/v1/orgs/{orgId}/providers', { query });
+        return response.providers || [];
+    }
+    /**
+     * Get a single provider by ID
+     */
+    async get(providerId) {
+        const orgId = await this.client.resolveOrgId();
+        const response = await this.client.request('GET', `/api/v1/orgs/${orgId}/providers/${providerId}`);
+        return response.provider;
+    }
+    /**
+     * Create a new provider
+     */
+    async create(params) {
+        const body = {
+            name: params.name,
+        };
+        if (params.email) {
+            body.email = params.email;
+        }
+        if (params.phone) {
+            body.phone = params.phone;
+        }
+        if (params.userId !== undefined) {
+            body.userId = params.userId;
+        }
+        if (params.bio) {
+            body.bio = params.bio;
+        }
+        if (params.externalId) {
+            body.externalId = params.externalId;
+        }
+        const response = await this.client.request('POST', '/api/v1/orgs/{orgId}/providers', { body });
+        return response.provider;
+    }
+}