@withaevum/sdk 0.0.1

package/dist/customers.d.ts

@@ -0,0 +1,33 @@
+import { AevumClient } from './client';
+import type { Customer, CreateCustomerParams, UpdateCustomerParams, 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>;
+    /**
+     * Update an existing customer
+     */
+    update(customerId: string, params: UpdateCustomerParams): Promise<Customer>;
+    /**
+     * Get customer booking history with analytics
+     */
+    getHistory(customerId: string): Promise<CustomerHistoryResponse>;
+    /**
+     * Delete a customer
+     */
+    delete(customerId: string): Promise<void>;
+}

package/dist/customers.js

@@ -0,0 +1,83 @@
+/**
+ * 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;
+    }
+    /**
+     * Update an existing customer
+     */
+    async update(customerId, 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;
+        }
+        const response = await this.client.request('PATCH', `/api/v1/orgs/{orgId}/customers/${customerId}`, { 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`);
+    }
+    /**
+     * Delete a customer
+     */
+    async delete(customerId) {
+        await this.client.request('DELETE', `/api/v1/orgs/{orgId}/customers/${customerId}`);
+    }
+}

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,14 @@
+export { AevumClient } from './client';
+export { BookingsAPI } from './bookings';
+export { OfferingsAPI } from './offerings';
+export { CustomersAPI } from './customers';
+export { ProvidersAPI } from './providers';
+export { OrgsAPI } from './orgs';
+export { CalendarAPI } from './calendar';
+export { AnalyticsAPI } from './analytics';
+export { AvailabilityAPI } from './availability';
+export { PaymentsAPI } from './payments';
+export { verifyWebhook, WebhookVerificationError, extractWebhookSignature, isBookingEvent, isPaymentEvent, isBookingCreatedEvent, isBookingUpdatedEvent, isBookingCancelledEvent, isBookingConfirmedEvent, isPaymentSucceededEvent, isPaymentFailedEvent, isPaymentRefundedEvent, isWebhookTestEvent, } from './webhooks';
+export type { WebhookEvent, WebhookEventType, BookingCreatedEvent, BookingUpdatedEvent, BookingCancelledEvent, BookingConfirmedEvent, PaymentSucceededEvent, PaymentFailedEvent, PaymentRefundedEvent, WebhookTestEvent, } from './webhooks';
+export * from './types';
+export * from './errors';

package/dist/index.js

@@ -0,0 +1,14 @@
+// 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 { OrgsAPI } from './orgs';
+export { CalendarAPI } from './calendar';
+export { AnalyticsAPI } from './analytics';
+export { AvailabilityAPI } from './availability';
+export { PaymentsAPI } from './payments';
+export { verifyWebhook, WebhookVerificationError, extractWebhookSignature, isBookingEvent, isPaymentEvent, isBookingCreatedEvent, isBookingUpdatedEvent, isBookingCancelledEvent, isBookingConfirmedEvent, isPaymentSucceededEvent, isPaymentFailedEvent, isPaymentRefundedEvent, isWebhookTestEvent, } from './webhooks';
+export * from './types';
+export * from './errors';

package/dist/offerings.d.ts

@@ -0,0 +1,107 @@
+import { AevumClient } from './client';
+import type { Offering, CreateOfferingParams, UpdateOfferingParams, 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>;
+    /**
+     * Update an existing offering
+     */
+    update(offeringId: string, params: UpdateOfferingParams): Promise<Offering>;
+    /**
+     * Delete an offering
+     */
+    delete(offeringId: string): Promise<void>;
+    /**
+     * 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>;
+}