go-scheduler-node-sdk 1.0.0

package/dist/resources/calendarMembers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarMembers = void 0;
+class CalendarMembers {
+    constructor(http) {
+        this.http = http;
+    }
+    async invite(calendarUID, data) {
+        return this.http.post(`/api/v1/calendars/${calendarUID}/members`, data);
+    }
+    async list(calendarUID, requestingAccountID) {
+        return this.http.get(`/api/v1/calendars/${calendarUID}/members`, {
+            params: { account_id: requestingAccountID },
+        });
+    }
+    async update(calendarUID, memberAccountID, requestingAccountID, data) {
+        return this.http.put(`/api/v1/calendars/${calendarUID}/members/${memberAccountID}`, data, {
+            params: { account_id: requestingAccountID },
+        });
+    }
+    async remove(calendarUID, memberAccountID, requestingAccountID) {
+        return this.http.delete(`/api/v1/calendars/${calendarUID}/members/${memberAccountID}`, {
+            params: { account_id: requestingAccountID },
+        });
+    }
+}
+exports.CalendarMembers = CalendarMembers;

package/dist/resources/calendars.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from "../utils/http";
+import { Calendar, CreateCalendarRequest, UpdateCalendarRequest, PagedResponse, ICSImportOptions, ICSImportResponse, ICSLinkImportOptions, ICSLinkImportResponse, ResyncResponse } from "../types";
+export declare class Calendars {
+    private http;
+    constructor(http: HttpClient);
+    create(data: CreateCalendarRequest): Promise<Calendar>;
+    get(calendarUID: string): Promise<Calendar>;
+    list(accountID: string, limit?: number, offset?: number): Promise<PagedResponse<Calendar>>;
+    update(calendarUID: string, data: UpdateCalendarRequest): Promise<Calendar>;
+    delete(calendarUID: string): Promise<void>;
+    /**
+     * Import events from an ICS file
+     * @param file - The ICS file to import (Buffer or Blob)
+     * @param options - Import options
+     * @returns Import response with summary and event results
+     */
+    importICS(file: Buffer | Blob, options: ICSImportOptions): Promise<ICSImportResponse>;
+    /**
+     * Import events from an ICS URL
+     * @param options - Import options including URL and authentication
+     * @returns Import response with summary and event results
+     */
+    importICSLink(options: ICSLinkImportOptions): Promise<ICSLinkImportResponse>;
+    /**
+     * Manually resync an ICS calendar
+     * @param calendarUID - The calendar UID to resync
+     * @returns Resync response with summary
+     */
+    resync(calendarUID: string): Promise<ResyncResponse>;
+}

package/dist/resources/calendars.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Calendars = void 0;
+class Calendars {
+    constructor(http) {
+        this.http = http;
+    }
+    async create(data) {
+        return this.http.post("/api/v1/calendars", data);
+    }
+    async get(calendarUID) {
+        return this.http.get(`/api/v1/calendars/${calendarUID}`);
+    }
+    async list(accountID, limit = 50, offset = 0) {
+        return this.http.get("/api/v1/calendars", {
+            params: {
+                account_id: accountID,
+                limit: limit.toString(),
+                offset: offset.toString(),
+            },
+        });
+    }
+    async update(calendarUID, data) {
+        return this.http.put(`/api/v1/calendars/${calendarUID}`, data);
+    }
+    async delete(calendarUID) {
+        return this.http.delete(`/api/v1/calendars/${calendarUID}`);
+    }
+    /**
+     * Import events from an ICS file
+     * @param file - The ICS file to import (Buffer or Blob)
+     * @param options - Import options
+     * @returns Import response with summary and event results
+     */
+    async importICS(file, options) {
+        const formData = new FormData();
+        // Add file
+        if (Buffer.isBuffer(file)) {
+            formData.append("file", new Blob([file]), "calendar.ics");
+        }
+        else {
+            formData.append("file", file, "calendar.ics");
+        }
+        // Add required fields
+        formData.append("account_id", options.accountId);
+        // Add optional fields
+        if (options.calendarUid) {
+            formData.append("calendar_uid", options.calendarUid);
+        }
+        if (options.calendarMetadata) {
+            formData.append("calendar_metadata", JSON.stringify(options.calendarMetadata));
+        }
+        if (options.importReminders !== undefined) {
+            formData.append("import_reminders", options.importReminders.toString());
+        }
+        if (options.importAttendees !== undefined) {
+            formData.append("import_attendees", options.importAttendees.toString());
+        }
+        return this.http.postForm("/api/v1/calendars/import/ics", formData);
+    }
+    /**
+     * Import events from an ICS URL
+     * @param options - Import options including URL and authentication
+     * @returns Import response with summary and event results
+     */
+    async importICSLink(options) {
+        const body = {
+            account_id: options.accountId,
+            ics_url: options.icsUrl,
+            auth_type: options.authType,
+            ...(options.authCredentials && {
+                auth_credentials: options.authCredentials,
+            }),
+            ...(options.syncIntervalSeconds && {
+                sync_interval_seconds: options.syncIntervalSeconds,
+            }),
+            ...(options.calendarMetadata && {
+                calendar_metadata: options.calendarMetadata,
+            }),
+            ...(options.syncOnPartialFailure !== undefined && {
+                sync_on_partial_failure: options.syncOnPartialFailure,
+            }),
+        };
+        return this.http.post("/api/v1/calendars/import/ics-link", body);
+    }
+    /**
+     * Manually resync an ICS calendar
+     * @param calendarUID - The calendar UID to resync
+     * @returns Resync response with summary
+     */
+    async resync(calendarUID) {
+        return this.http.post(`/api/v1/calendars/${calendarUID}/resync`, {});
+    }
+}
+exports.Calendars = Calendars;

package/dist/resources/events.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from "../utils/http";
+import { Event, CreateEventRequest, UpdateEventRequest, GetCalendarEventsRequest, PagedResponse } from "../types";
+export declare class Events {
+    private http;
+    constructor(http: HttpClient);
+    create(data: CreateEventRequest): Promise<Event>;
+    get(eventUID: string): Promise<Event>;
+    getCalendarEvents(data: GetCalendarEventsRequest): Promise<PagedResponse<Event>>;
+    update(eventUID: string, data: UpdateEventRequest): Promise<Event>;
+    delete(eventUID: string, accountID: string, scope?: "single" | "all"): Promise<void>;
+    toggleCancelled(eventUID: string): Promise<Event>;
+    transferOwnership(eventUID: string, newOrganizerAccountID: string, newOrganizerCalendarUID: string, scope?: "single" | "all"): Promise<{
+        message: string;
+        new_organizer: any;
+        scope: string;
+        count: number;
+    }>;
+}

package/dist/resources/events.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+class Events {
+    constructor(http) {
+        this.http = http;
+    }
+    async create(data) {
+        return this.http.post("/api/v1/events", data);
+    }
+    async get(eventUID) {
+        return this.http.get(`/api/v1/events/${eventUID}`);
+    }
+    async getCalendarEvents(data) {
+        return this.http.post("/api/v1/calendars/events", data);
+    }
+    async update(eventUID, data) {
+        return this.http.put(`/api/v1/events/${eventUID}`, data);
+    }
+    async delete(eventUID, accountID, scope) {
+        const params = { account_id: accountID };
+        if (scope) {
+            params.scope = scope;
+        }
+        return this.http.delete(`/api/v1/events/${eventUID}`, {
+            params,
+        });
+    }
+    async toggleCancelled(eventUID) {
+        return this.http.post(`/api/v1/events/${eventUID}/toggle-cancelled`);
+    }
+    async transferOwnership(eventUID, newOrganizerAccountID, newOrganizerCalendarUID, scope) {
+        return this.http.post(`/api/v1/events/${eventUID}/transfer-ownership`, {
+            new_organizer_account_id: newOrganizerAccountID,
+            new_organizer_calendar_uid: newOrganizerCalendarUID,
+            scope,
+        });
+    }
+}
+exports.Events = Events;

package/dist/resources/reminders.d.ts

@@ -0,0 +1,22 @@
+import { HttpClient } from "../utils/http";
+import { Reminder, CreateReminderRequest, UpdateReminderRequest } from "../types";
+export declare class Reminders {
+    private http;
+    constructor(http: HttpClient);
+    create(eventUID: string, data: CreateReminderRequest): Promise<{
+        reminder: Reminder;
+        scope: string;
+        count: number;
+    }>;
+    list(eventUID: string, accountID?: string): Promise<Reminder[]>;
+    update(eventUID: string, reminderUID: string, data: UpdateReminderRequest): Promise<{
+        reminder: Reminder;
+        scope: string;
+        count: number;
+    }>;
+    delete(eventUID: string, reminderUID: string, scope?: "single" | "all"): Promise<{
+        message: string;
+        scope: string;
+        count: number;
+    }>;
+}

package/dist/resources/reminders.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reminders = void 0;
+class Reminders {
+    constructor(http) {
+        this.http = http;
+    }
+    async create(eventUID, data) {
+        return this.http.post(`/api/v1/events/${eventUID}/reminders`, data);
+    }
+    async list(eventUID, accountID) {
+        const params = accountID ? { account_id: accountID } : undefined;
+        return this.http.get(`/api/v1/events/${eventUID}/reminders`, {
+            params,
+        });
+    }
+    async update(eventUID, reminderUID, data) {
+        return this.http.put(`/api/v1/events/${eventUID}/reminders/${reminderUID}`, data);
+    }
+    async delete(eventUID, reminderUID, scope) {
+        const params = scope ? { scope } : undefined;
+        return this.http.delete(`/api/v1/events/${eventUID}/reminders/${reminderUID}`, {
+            params,
+        });
+    }
+}
+exports.Reminders = Reminders;

package/dist/resources/webhooks.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from "../utils/http";
+import { Webhook, CreateWebhookRequest, UpdateWebhookRequest, WebhookDelivery, PagedResponse } from "../types";
+export declare class Webhooks {
+    private http;
+    constructor(http: HttpClient);
+    create(data: CreateWebhookRequest): Promise<Webhook>;
+    get(webhookUID: string): Promise<Webhook>;
+    list(limit?: number, offset?: number): Promise<PagedResponse<Webhook>>;
+    update(webhookUID: string, data: UpdateWebhookRequest): Promise<Webhook>;
+    delete(webhookUID: string): Promise<void>;
+    getDeliveries(webhookUID: string, limit?: number, offset?: number): Promise<PagedResponse<WebhookDelivery>>;
+}

package/dist/resources/webhooks.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhooks = void 0;
+class Webhooks {
+    constructor(http) {
+        this.http = http;
+    }
+    async create(data) {
+        return this.http.post("/api/v1/webhooks", data);
+    }
+    async get(webhookUID) {
+        return this.http.get(`/api/v1/webhooks/${webhookUID}`);
+    }
+    async list(limit = 50, offset = 0) {
+        return this.http.get("/api/v1/webhooks", {
+            params: { limit, offset },
+        });
+    }
+    async update(webhookUID, data) {
+        return this.http.put(`/api/v1/webhooks/${webhookUID}`, data);
+    }
+    async delete(webhookUID) {
+        return this.http.delete(`/api/v1/webhooks/${webhookUID}`);
+    }
+    async getDeliveries(webhookUID, limit = 50, offset = 0) {
+        return this.http.get(`/api/v1/webhooks/deliveries/${webhookUID}`, {
+            params: { limit, offset },
+        });
+    }
+}
+exports.Webhooks = Webhooks;

package/dist/types.d.ts

@@ -0,0 +1,338 @@
+export interface SchedulerConfig {
+    baseURL: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+export interface Calendar {
+    calendar_uid: string;
+    account_id: string;
+    name?: string;
+    description?: string;
+    timezone?: string;
+    metadata?: Record<string, any>;
+    created_ts: number;
+    updated_ts: number;
+    ics_url?: string | null;
+    ics_auth_type?: string | null;
+    ics_last_sync_ts?: number | null;
+    ics_last_sync_status?: string | null;
+    ics_sync_interval_seconds?: number | null;
+    ics_error_message?: string | null;
+    ics_last_etag?: string | null;
+    ics_last_modified?: string | null;
+    is_read_only?: boolean;
+    sync_on_partial_failure?: boolean;
+}
+export interface CreateCalendarRequest {
+    account_id: string;
+    name?: string;
+    description?: string;
+    timezone?: string;
+    metadata?: Record<string, any>;
+}
+export interface UpdateCalendarRequest {
+    name?: string;
+    description?: string;
+    timezone?: string;
+    metadata?: Record<string, any>;
+}
+export interface Recurrence {
+    rule: string;
+    until?: number;
+    count?: number;
+}
+export interface Event {
+    event_uid: string;
+    calendar_uid: string;
+    account_id: string;
+    start_ts: number;
+    end_ts: number;
+    duration: number;
+    timezone?: string;
+    local_start?: string;
+    metadata?: Record<string, any>;
+    recurrence?: Recurrence;
+    recurrence_status?: string;
+    recurrence_end_ts?: number;
+    is_recurring_instance?: boolean;
+    is_modified?: boolean;
+    master_event_uid?: string;
+    original_start_ts?: number;
+    exdates_ts?: number[];
+    is_cancelled?: boolean;
+    created_ts: number;
+    updated_ts: number;
+}
+export interface CreateEventRequest {
+    calendar_uid: string;
+    account_id: string;
+    start_ts: number;
+    end_ts: number;
+    timezone?: string;
+    local_start?: string;
+    metadata?: Record<string, any>;
+    recurrence?: Recurrence;
+}
+export type UpdateScope = "single" | "future" | "all";
+export interface UpdateEventRequest {
+    account_id: string;
+    start_ts: number;
+    end_ts: number;
+    timezone?: string;
+    local_start?: string;
+    metadata?: Record<string, any>;
+    recurrence?: Recurrence;
+    scope?: UpdateScope;
+}
+export interface GetCalendarEventsRequest {
+    calendar_uids: string[];
+    start_ts: number;
+    end_ts: number;
+}
+export interface Reminder {
+    reminder_uid?: string;
+    reminder_group_id?: string;
+    event_uid: string;
+    account_id: string;
+    offset_seconds: number;
+    trigger_ts?: number;
+    metadata?: Record<string, any>;
+    is_delivered?: boolean;
+    delivered_ts?: number;
+    is_archived?: boolean;
+    created_ts?: number;
+    updated_ts?: number;
+}
+export interface CreateReminderRequest {
+    offset_seconds: number;
+    account_id: string;
+    metadata?: Record<string, any>;
+    scope?: "single" | "all";
+}
+export interface UpdateReminderRequest {
+    offset_seconds: number;
+    metadata?: Record<string, any>;
+    scope?: "single" | "all";
+}
+export interface Webhook {
+    webhook_uid: string;
+    url: string;
+    event_types?: string[];
+    secret: string;
+    retry_count: number;
+    timeout_seconds: number;
+    failure_count?: number;
+    is_active?: boolean;
+    created_ts: number;
+    updated_ts: number;
+}
+export interface CreateWebhookRequest {
+    url: string;
+    event_types?: string[];
+    secret?: string;
+    retry_count?: number;
+    timeout_seconds?: number;
+}
+export interface UpdateWebhookRequest {
+    url?: string;
+    event_types?: string[];
+    retry_count?: number;
+    timeout_seconds?: number;
+    is_active?: boolean;
+}
+export interface WebhookDelivery {
+    delivery_uid: string;
+    webhook_uid: string;
+    event_type: string;
+    payload: Record<string, any>;
+    status_code?: number;
+    response_body?: string;
+    error_message?: string;
+    attempt_count: number;
+    created_ts: number;
+    delivered_ts?: number;
+}
+export interface Attendee {
+    attendee_uid: string;
+    event_uid: string;
+    account_id: string;
+    role: "organizer" | "attendee";
+    rsvp_status: "pending" | "accepted" | "declined" | "tentative";
+    attendee_group_id?: string;
+    metadata?: Record<string, any>;
+    created_ts: number;
+    updated_ts: number;
+}
+export interface CreateAttendeeRequest {
+    account_id: string;
+    role?: "organizer" | "attendee";
+    metadata?: Record<string, any>;
+    scope?: "single" | "all";
+}
+export interface UpdateAttendeeRequest {
+    role?: "organizer" | "attendee";
+    metadata?: Record<string, any>;
+    scope?: "single" | "all";
+}
+export interface UpdateAttendeeRSVPRequest {
+    rsvp_status: "pending" | "accepted" | "declined" | "tentative";
+    scope?: "single" | "all";
+}
+export interface TransferOwnershipRequest {
+    new_organizer_account_id: string;
+    new_organizer_calendar_uid: string;
+    scope?: "single" | "all";
+}
+export interface CalendarMember {
+    calendar_uid: string;
+    account_id: string;
+    role: "read" | "write";
+    status: "pending" | "confirmed";
+    created_ts: number;
+    updated_ts: number;
+}
+export interface InviteCalendarMembersRequest {
+    account_id: string;
+    account_ids: string[];
+    role: "read" | "write";
+}
+export interface UpdateCalendarMemberRequest {
+    role?: "read" | "write";
+    status?: "pending" | "confirmed";
+}
+export interface PagedResponse<T> {
+    data: T[];
+    total: number;
+    limit?: number;
+    offset?: number;
+}
+export interface ErrorResponse {
+    error: string;
+    details?: string;
+}
+export interface ICSImportOptions {
+    accountId: string;
+    calendarUid?: string;
+    calendarMetadata?: Record<string, any>;
+    importReminders?: boolean;
+    importAttendees?: boolean;
+}
+export interface ICSImportSummary {
+    total_events: number;
+    imported_events: number;
+    failed_events: number;
+}
+export interface ICSImportEventResult {
+    ics_uid: string;
+    event_uid?: string;
+    status: "success" | "failed";
+    error?: string;
+}
+export interface ICSImportResponse {
+    calendar: Calendar;
+    summary: ICSImportSummary;
+    events: ICSImportEventResult[];
+}
+export interface ICSLinkImportOptions {
+    accountId: string;
+    icsUrl: string;
+    authType: "none" | "basic" | "bearer";
+    authCredentials?: string;
+    syncIntervalSeconds?: number;
+    calendarMetadata?: Record<string, any>;
+    syncOnPartialFailure?: boolean;
+}
+export interface ICSLinkImportResponse {
+    calendar: Calendar;
+    summary: ICSImportSummary;
+    events: ICSImportEventResult[];
+    sync_scheduled: boolean;
+}
+export interface ResyncResponse {
+    calendar: Calendar;
+    imported_events: number;
+    failed_events: number;
+    warnings: string[];
+}
+export type WebhookEventType = "event.created" | "event.updated" | "event.deleted" | "event.cancelled" | "event.uncancelled" | "event.ownership_transferred" | "calendar.created" | "calendar.updated" | "calendar.deleted" | "calendar.synced" | "calendar.resynced" | "member.invited" | "member.accepted" | "member.rejected" | "member.removed" | "member.status_updated" | "member.role_updated" | "reminder.created" | "reminder.updated" | "reminder.deleted" | "reminder.triggered" | "reminder.due" | "attendee.created" | "attendee.updated" | "attendee.deleted" | "attendee.rsvp_updated";
+export interface WebhookPayload<T = any> {
+    webhook_uid: string;
+    event_type: WebhookEventType;
+    delivery_id: string;
+    timestamp: number;
+    data: T;
+}
+export interface CalendarWebhookData {
+    calendar_uid: string;
+    account_id: string;
+    created_ts?: number;
+    updated_ts?: number;
+    metadata?: Record<string, any>;
+}
+export interface CalendarSyncedWebhookData {
+    calendar_uid: string;
+    account_id: string;
+    imported_events: number;
+    failed_events: number;
+    warnings: string[];
+    sync_ts: number;
+    manual_trigger: boolean;
+}
+export interface EventWebhookData {
+    event_uid: string;
+    calendar_uid: string;
+    account_id: string;
+    start_ts: number;
+    end_ts?: number;
+    metadata?: Record<string, any>;
+}
+export interface EventBatchWebhookData {
+    events: EventWebhookData[];
+    count: number;
+}
+export interface ReminderWebhookData {
+    reminder_uid: string;
+    event_uid: string;
+    account_id: string;
+    offset_seconds: number;
+    metadata?: Record<string, any>;
+}
+export interface ReminderDueWebhookData {
+    reminder_uid: string;
+    event_uid: string;
+    account_id: string;
+    offset_seconds: number;
+    remind_at_ts: number;
+    reminder_metadata?: Record<string, any>;
+    event: {
+        event_uid: string;
+        calendar_uid: string;
+        start_ts: number;
+        event_metadata?: Record<string, any>;
+    };
+}
+export interface AttendeeWebhookData {
+    event_uid: string;
+    account_id: string;
+    role: "organizer" | "attendee";
+    rsvp_status: "pending" | "accepted" | "declined" | "tentative";
+    scope?: "single" | "all";
+    count?: number;
+}
+export interface MemberWebhookData {
+    calendar_uid: string;
+    account_id: string;
+    role: "read" | "write";
+    status: "pending" | "confirmed";
+    invited_by: string;
+}
+export interface WebhookVerificationResult {
+    valid: boolean;
+    error?: string;
+}
+export declare function isCalendarWebhook(payload: WebhookPayload): payload is WebhookPayload<CalendarWebhookData>;
+export declare function isCalendarSyncedWebhook(payload: WebhookPayload): payload is WebhookPayload<CalendarSyncedWebhookData>;
+export declare function isEventWebhook(payload: WebhookPayload): payload is WebhookPayload<EventWebhookData | EventWebhookData[]>;
+export declare function isReminderDueWebhook(payload: WebhookPayload): payload is WebhookPayload<ReminderDueWebhookData>;
+export declare function isAttendeeWebhook(payload: WebhookPayload): payload is WebhookPayload<AttendeeWebhookData>;
+export declare function isMemberWebhook(payload: WebhookPayload): payload is WebhookPayload<MemberWebhookData>;

package/dist/types.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCalendarWebhook = isCalendarWebhook;
+exports.isCalendarSyncedWebhook = isCalendarSyncedWebhook;
+exports.isEventWebhook = isEventWebhook;
+exports.isReminderDueWebhook = isReminderDueWebhook;
+exports.isAttendeeWebhook = isAttendeeWebhook;
+exports.isMemberWebhook = isMemberWebhook;
+// Type guards for webhook payloads
+function isCalendarWebhook(payload) {
+    return (payload.event_type.startsWith("calendar.") &&
+        payload.event_type !== "calendar.synced" &&
+        payload.event_type !== "calendar.resynced");
+}
+function isCalendarSyncedWebhook(payload) {
+    return (payload.event_type === "calendar.synced" ||
+        payload.event_type === "calendar.resynced");
+}
+function isEventWebhook(payload) {
+    return payload.event_type.startsWith("event.");
+}
+function isReminderDueWebhook(payload) {
+    return (payload.event_type === "reminder.due" ||
+        payload.event_type === "reminder.triggered");
+}
+function isAttendeeWebhook(payload) {
+    return payload.event_type.startsWith("attendee.");
+}
+function isMemberWebhook(payload) {
+    return payload.event_type.startsWith("member.");
+}