@epilot/sdk 2.4.3 → 2.4.4-alpha.0

package/dist/{js-yaml-DLCVPJ7G.js → js-yaml-UPZKYVRY.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../../node_modules/.pnpm/js-yaml@4.1.1/node_modules/js-yaml/dist/js-yaml.mjs
+// ../../node_modules/js-yaml/dist/js-yaml.mjs
 function isNothing(subject) {
   return typeof subject === "undefined" || subject === null;
 }
@@ -864,18 +864,6 @@ function charFromCodepoint(c) {
     (c - 65536 & 1023) + 56320
   );
 }
-function setProperty(object, key, value) {
-  if (key === "__proto__") {
-    Object.defineProperty(object, key, {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value
-    });
-  } else {
-    object[key] = value;
-  }
-}
 var simpleEscapeCheck = new Array(256);
 var simpleEscapeMap = new Array(256);
 for (i = 0; i < 256; i++) {
@@ -995,7 +983,7 @@ function mergeMappings(state, destination, source, overridableKeys) {
   for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
     key = sourceKeys[index];
     if (!_hasOwnProperty$1.call(destination, key)) {
-      setProperty(destination, key, source[key]);
+      destination[key] = source[key];
       overridableKeys[key] = true;
     }
   }
@@ -1035,7 +1023,16 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
       state.position = startPos || state.position;
       throwError(state, "duplicated mapping key");
     }
-    setProperty(_result, keyNode, valueNode);
+    if (keyNode === "__proto__") {
+      Object.defineProperty(_result, keyNode, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: valueNode
+      });
+    } else {
+      _result[keyNode] = valueNode;
+    }
     delete overridableKeys[keyNode];
   }
   return _result;
@@ -2623,6 +2620,7 @@ var jsYaml = {
   safeLoadAll,
   safeDump
 };
+var js_yaml_default = jsYaml;
 export {
   CORE_SCHEMA,
   DEFAULT_SCHEMA,
@@ -2631,7 +2629,7 @@ export {
   Schema,
   Type,
   YAMLException,
-  jsYaml as default,
+  js_yaml_default as default,
   dump,
   load,
   loadAll,
@@ -2643,5 +2641,5 @@ export {
 /*! Bundled license information:
 
 js-yaml/dist/js-yaml.mjs:
-  (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)
+  (*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT *)
 */

package/dist/large-response.d.ts

@@ -0,0 +1,9 @@
+import type { AxiosInstance } from 'axios';
+export type LargeResponseConfig = {
+    /** Enable large response handling. Default: true */
+    enabled?: boolean;
+};
+export declare const applyLargeResponseInterceptor: (params: {
+    client: AxiosInstance;
+    config: LargeResponseConfig;
+}) => void;

package/dist/openapi.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lazy-loaded OpenAPI spec — returns the full OpenAPI JSON document for an API.
+ * Each spec is loaded via dynamic import() so only the requested spec affects bundle size.
+ */
+import type { Document } from 'openapi-client-axios';
+/**
+ * Get the full OpenAPI specification for an API.
+ *
+ * @example
+ * await openapi('entity')   // full entity OpenAPI spec
+ */
+export declare const openapi: (apiName: string) => Promise<Document>;

package/dist/overrides.d.ts

@@ -0,0 +1,9 @@
+import type { ApiEntry } from './types';
+/**
+ * Loads overrides from .epilot/sdk-overrides.json synchronously.
+ * Only performs filesystem reads on first call - subsequent calls are no-ops.
+ * Safe to call in browser environments (fs/path are dynamically required).
+ */
+export declare const loadOverrides: (registry: Map<string, ApiEntry>, cwd?: string) => void;
+/** Reset override loading state (for testing) */
+export declare const _resetOverrides: () => void;

package/dist/proxy.d.ts

@@ -0,0 +1,14 @@
+import type { AxiosInstance } from 'axios';
+import type { ApiHandle } from './types';
+/**
+ * Creates an ApiHandle — a proxy that exposes explicit getClient() / createClient()
+ * and forwards any other property access as an operation call on the lazy singleton.
+ *
+ * help() and openapi() are attached to clients at creation time in client-factory.ts,
+ * so they work regardless of how the client is obtained.
+ */
+export declare const createApiHandle: <T extends AxiosInstance>(params: {
+    resolveClient: () => T;
+    createClient: () => T;
+    apiName?: string;
+}) => ApiHandle<T>;

package/dist/registry.d.ts

@@ -0,0 +1,19 @@
+import type { AxiosInstance } from 'axios';
+import type { Document } from 'openapi-client-axios';
+import type { ApiEntry, SDKState } from './types';
+export declare const createRegistry: () => Map<string, ApiEntry>;
+export declare const registerApi: (params: {
+    registry: Map<string, ApiEntry>;
+    name: string;
+    loader: () => Document;
+}) => void;
+export declare const resolveClient: (params: {
+    registry: Map<string, ApiEntry>;
+    name: string;
+    state: SDKState;
+}) => AxiosInstance;
+export declare const resetClient: (params: {
+    registry: Map<string, ApiEntry>;
+    name: string;
+}) => void;
+export declare const resetAllClients: (registry: Map<string, ApiEntry>) => void;

package/dist/retry.d.ts

@@ -0,0 +1,11 @@
+import type { AxiosInstance } from 'axios';
+export type RetryConfig = {
+    /** Maximum number of retries for 429 responses. Set to 0 to disable. Default: 3 */
+    maxRetries?: number;
+    /** Default delay in ms when Retry-After header is missing. Default: 1000 */
+    defaultDelayMs?: number;
+};
+export declare const applyRetryInterceptor: (params: {
+    client: AxiosInstance;
+    config: RetryConfig;
+}) => void;

package/dist/sdk.d.ts

@@ -0,0 +1,29 @@
+import type { AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import type { TokenArg } from './authorize';
+import type { SDKClientMap } from './client-map';
+import type { LargeResponseConfig } from './large-response';
+import type { RetryConfig } from './retry';
+import type { ApiHandle, HeadersConfig } from './types';
+export type InterceptorUse = {
+    request: (fulfilled: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>, rejected?: (error: unknown) => unknown) => void;
+    response: (fulfilled: (response: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>, rejected?: (error: unknown) => unknown) => void;
+};
+export type EpilotSDK = {
+    /** Set a Bearer token (static string or async function) for all clients */
+    authorize: (token: TokenArg) => void;
+    /** Set global default headers applied to all clients (e.g. x-epilot-org-id) */
+    headers: (headers: HeadersConfig) => void;
+    /** Register global axios interceptors applied to all clients */
+    interceptors: InterceptorUse;
+    /** Configure retry behavior for 429 Too Many Requests responses */
+    retry: (config: RetryConfig) => void;
+    /** Configure large response handling for S3-backed payloads */
+    largeResponse: (config: LargeResponseConfig) => void;
+    /** Get markdown docs. No args = general SDK help, with API name = API-specific docs */
+    help: (apiName?: string) => Promise<string>;
+    /** Get the full OpenAPI specification for an API (lazy-loaded) */
+    openapi: (apiName: string) => Promise<import('openapi-client-axios').Document>;
+} & {
+    [K in keyof SDKClientMap]: ApiHandle<SDKClientMap[K]>;
+} & Record<string, ApiHandle<AxiosInstance>>;
+export declare const createSDK: () => EpilotSDK;

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+import type { AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import type { Document } from 'openapi-client-axios';
+import type { LargeResponseConfig } from './large-response';
+import type { RetryConfig } from './retry';
+export type ApiEntry = {
+    loader: () => Document;
+    instance: AxiosInstance | null;
+};
+export type RequestInterceptor = {
+    type: 'request';
+    fulfilled: (config: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+    rejected?: (error: unknown) => unknown;
+};
+export type ResponseInterceptor = {
+    type: 'response';
+    fulfilled: (response: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>;
+    rejected?: (error: unknown) => unknown;
+};
+export type Interceptor = RequestInterceptor | ResponseInterceptor;
+export type SDKState = {
+    token: string | null;
+    tokenFn: (() => string | Promise<string>) | null;
+    globalHeaders: Record<string, string>;
+    interceptors: Interceptor[];
+    retry: RetryConfig;
+    largeResponse: LargeResponseConfig;
+};
+export type HeadersConfig = Record<string, string>;
+export type OverridesConfig = Record<string, string>;
+/**
+ * A non-API extension mounted on the SDK.
+ * Unlike ApiEntry (OpenAPI-based), extensions are plain objects
+ * with arbitrary methods and properties (e.g. factory functions, utilities).
+ */
+export type ExtensionEntry = {
+    value: unknown;
+};
+/**
+ * An API handle that provides:
+ * - `getClient()` — cached singleton
+ * - `createClient()` — fresh instance
+ * - Any operation method (e.g. `.getEntity(...)`) — auto-resolved via lazy singleton
+ */
+export type ApiHandle<T extends AxiosInstance = AxiosInstance> = {
+    /** Get the cached singleton client instance (lazy-initialized on first call) */
+    getClient: () => T;
+    /** Create a fresh client instance (not cached) */
+    createClient: () => T;
+    /** Get the full OpenAPI specification document (lazy-loaded) */
+    openapi: () => Promise<Document>;
+} & {
+    [K in keyof T]: T[K];
+};

package/docs/calendar.md

@@ -0,0 +1,441 @@
+# Calendar API
+
+- **Base URL:** `https://calendar.sls.epilot.io`
+- **Full API Docs:** [https://docs.epilot.io/api/calendar](https://docs.epilot.io/api/calendar)
+
+## Usage
+
+```ts
+import { epilot } from '@epilot/sdk'
+
+epilot.authorize(() => '<token>')
+const { data } = await epilot.calendar.listCalendars(...)
+```
+
+### Tree-shakeable import
+
+```ts
+import { getClient, authorize } from '@epilot/sdk/calendar'
+
+const calendarClient = getClient()
+authorize(calendarClient, () => '<token>')
+const { data } = await calendarClient.listCalendars(...)
+```
+
+## Operations
+
+**Calendars**
+- [`listCalendars`](#listcalendars)
+- [`getCalendar`](#getcalendar)
+
+**Events**
+- [`listEvents`](#listevents)
+- [`getEvent`](#getevent)
+
+**Schemas**
+- [`Calendar`](#calendar)
+- [`CalendarSource`](#calendarsource)
+- [`Provider`](#provider)
+- [`Error`](#error)
+- [`CalendarEvent`](#calendarevent)
+- [`EventType`](#eventtype)
+- [`EventStatus`](#eventstatus)
+- [`Sensitivity`](#sensitivity)
+- [`Importance`](#importance)
+- [`ResponseStatus`](#responsestatus)
+- [`Attendee`](#attendee)
+- [`EventSource`](#eventsource)
+
+### `listCalendars`
+
+List calendars visible to the caller.
+
+`GET /v1/calendar`
+
+```ts
+const { data } = await client.listCalendars({
+  size: 1,
+  cursor: 'example',
+})
+```
+
+<details>
+<summary>Response</summary>
+
+```json
+{
+  "results": [
+    {
+      "_id": "string",
+      "_schema": "calendar",
+      "_org": "string",
+      "_title": "string",
+      "name": "string",
+      "description": "string",
+      "color": "string",
+      "is_default": true,
+      "read_only": true,
+      "owner_email": "user@example.com",
+      "source": {
+        "type": "native",
+        "provider": "outlook",
+        "provider_calendar_id": "string",
+        "last_synced_at": "1970-01-01T00:00:00.000Z"
+      },
+      "_created_at": "1970-01-01T00:00:00.000Z",
+      "_updated_at": "1970-01-01T00:00:00.000Z"
+    }
+  ],
+  "next_cursor": "string"
+}
+```
+
+</details>
+
+---
+
+### `getCalendar`
+
+Get a single calendar by its epilot ID.
+
+`GET /v1/calendar/{calendar_id}`
+
+```ts
+const { data } = await client.getCalendar({
+  calendar_id: 'example',
+})
+```
+
+<details>
+<summary>Response</summary>
+
+```json
+{
+  "_id": "string",
+  "_schema": "calendar",
+  "_org": "string",
+  "_title": "string",
+  "name": "string",
+  "description": "string",
+  "color": "string",
+  "is_default": true,
+  "read_only": true,
+  "owner_email": "user@example.com",
+  "source": {
+    "type": "native",
+    "provider": "outlook",
+    "provider_calendar_id": "string",
+    "last_synced_at": "1970-01-01T00:00:00.000Z"
+  },
+  "_created_at": "1970-01-01T00:00:00.000Z",
+  "_updated_at": "1970-01-01T00:00:00.000Z"
+}
+```
+
+</details>
+
+---
+
+### `listEvents`
+
+List events in a time window. Recurring events are returned as expanded occurrences – each instance appears as its own event.
+
+`GET /v1/calendar/events`
+
+```ts
+const { data } = await client.listEvents({
+  from: 'example',
+  to: 'example',
+  calendar_id: 'example',
+  size: 1,
+  cursor: 'example',
+})
+```
+
+<details>
+<summary>Response</summary>
+
+```json
+{
+  "results": [
+    {
+      "_id": "string",
+      "_schema": "calendar_event",
+      "_org": "string",
+      "_title": "string",
+      "_tags": ["string"],
+      "calendar_id": "string",
+      "event_type": "singleInstance",
+      "description": "string",
+      "start_time": "1970-01-01T00:00:00.000Z",
+      "end_time": "1970-01-01T00:00:00.000Z",
+      "timezone": "string",
+      "is_all_day": true,
+      "location": "string",
+      "status": "free",
+      "busy": true,
+      "is_cancelled": true,
+      "sensitivity": "normal",
+      "importance": "low",
+      "is_online_meeting": true,
+      "online_meeting_url": "https://example.com/path",
+      "web_link": "https://example.com/path",
+      "response_status": "none",
+      "organizer_email": "user@example.com",
+      "attendees": [
+        {
+          "email": "user@example.com",
+          "name": "string",
+          "response": "none",
+          "type": "required"
+        }
+      ],
+      "is_recurring": true,
+      "series_master_id": "string",
+      "source": {
+        "type": "native",
+        "provider": "outlook",
+        "provider_event_id": "string",
+        "provider_event_url": "https://example.com/path",
+        "last_synced_at": "1970-01-01T00:00:00.000Z",
+        "etag": "string"
+      },
+      "_created_at": "1970-01-01T00:00:00.000Z",
+      "_updated_at": "1970-01-01T00:00:00.000Z"
+    }
+  ],
+  "next_cursor": "string"
+}
+```
+
+</details>
+
+---
+
+### `getEvent`
+
+Get a single event by its epilot ID.
+
+`GET /v1/calendar/events/{event_id}`
+
+```ts
+const { data } = await client.getEvent({
+  event_id: 'example',
+})
+```
+
+<details>
+<summary>Response</summary>
+
+```json
+{
+  "_id": "string",
+  "_schema": "calendar_event",
+  "_org": "string",
+  "_title": "string",
+  "_tags": ["string"],
+  "calendar_id": "string",
+  "event_type": "singleInstance",
+  "description": "string",
+  "start_time": "1970-01-01T00:00:00.000Z",
+  "end_time": "1970-01-01T00:00:00.000Z",
+  "timezone": "string",
+  "is_all_day": true,
+  "location": "string",
+  "status": "free",
+  "busy": true,
+  "is_cancelled": true,
+  "sensitivity": "normal",
+  "importance": "low",
+  "is_online_meeting": true,
+  "online_meeting_url": "https://example.com/path",
+  "web_link": "https://example.com/path",
+  "response_status": "none",
+  "organizer_email": "user@example.com",
+  "attendees": [
+    {
+      "email": "user@example.com",
+      "name": "string",
+      "response": "none",
+      "type": "required"
+    }
+  ],
+  "is_recurring": true,
+  "series_master_id": "string",
+  "source": {
+    "type": "native",
+    "provider": "outlook",
+    "provider_event_id": "string",
+    "provider_event_url": "https://example.com/path",
+    "last_synced_at": "1970-01-01T00:00:00.000Z",
+    "etag": "string"
+  },
+  "_created_at": "1970-01-01T00:00:00.000Z",
+  "_updated_at": "1970-01-01T00:00:00.000Z"
+}
+```
+
+</details>
+
+---
+
+## Schemas
+
+### `Calendar`
+
+```ts
+type Calendar = {
+  _id: string
+  _schema: "calendar"
+  _org: string
+  _title?: string
+  name: string
+  description?: string
+  color?: string
+  is_default: boolean
+  read_only: boolean
+  owner_email?: string // email
+  source: {
+    type: "native" | "synced"
+    provider?: "outlook" | "google" | null
+    provider_calendar_id?: string
+    last_synced_at?: string // date-time
+  }
+  _created_at?: string // date-time
+  _updated_at?: string // date-time
+}
+```
+
+### `CalendarSource`
+
+```ts
+type CalendarSource = {
+  type: "native" | "synced"
+  provider?: "outlook" | "google" | null
+  provider_calendar_id?: string
+  last_synced_at?: string // date-time
+}
+```
+
+### `Provider`
+
+Null for native epilot calendars
+
+```ts
+type Provider = "outlook" | "google" | null
+```
+
+### `Error`
+
+```ts
+type Error = {
+  message: string
+  code?: string
+}
+```
+
+### `CalendarEvent`
+
+```ts
+type CalendarEvent = {
+  _id: string
+  _schema: "calendar_event"
+  _org: string
+  _title?: string
+  _tags?: string[]
+  calendar_id: string
+  event_type: "singleInstance" | "occurrence" | "exception" | "seriesMaster"
+  description?: string
+  start_time: string // date-time
+  end_time: string // date-time
+  timezone: string
+  is_all_day: boolean
+  location?: string
+  status: "free" | "tentative" | "busy" | "oof" | "workingElsewhere" | "unknown"
+  busy: boolean
+  is_cancelled: boolean
+  sensitivity: "normal" | "personal" | "private" | "confidential"
+  importance: "low" | "normal" | "high"
+  is_online_meeting: boolean
+  online_meeting_url?: string // uri
+  web_link?: string // uri
+  response_status: "none" | "organizer" | "tentativelyAccepted" | "accepted" | "declined" | "notResponded"
+  organizer_email?: string // email
+  attendees?: Array<{
+    email: string // email
+    name?: string
+    response: "none" | "organizer" | "tentativelyAccepted" | "accepted" | "declined" | "notResponded"
+    type: "required" | "optional" | "resource"
+  }>
+  is_recurring: boolean
+  series_master_id?: string
+  source: {
+    type: "native" | "synced"
+    provider?: "outlook" | "google" | null
+    provider_event_id?: string
+    provider_event_url?: string // uri
+    last_synced_at?: string // date-time
+    etag?: string
+  }
+  _created_at?: string // date-time
+  _updated_at?: string // date-time
+}
+```
+
+### `EventType`
+
+```ts
+type EventType = "singleInstance" | "occurrence" | "exception" | "seriesMaster"
+```
+
+### `EventStatus`
+
+Free/busy state derived from provider `showAs`
+
+```ts
+type EventStatus = "free" | "tentative" | "busy" | "oof" | "workingElsewhere" | "unknown"
+```
+
+### `Sensitivity`
+
+```ts
+type Sensitivity = "normal" | "personal" | "private" | "confidential"
+```
+
+### `Importance`
+
+```ts
+type Importance = "low" | "normal" | "high"
+```
+
+### `ResponseStatus`
+
+Caller's response to the invite
+
+```ts
+type ResponseStatus = "none" | "organizer" | "tentativelyAccepted" | "accepted" | "declined" | "notResponded"
+```
+
+### `Attendee`
+
+```ts
+type Attendee = {
+  email: string // email
+  name?: string
+  response: "none" | "organizer" | "tentativelyAccepted" | "accepted" | "declined" | "notResponded"
+  type: "required" | "optional" | "resource"
+}
+```
+
+### `EventSource`
+
+```ts
+type EventSource = {
+  type: "native" | "synced"
+  provider?: "outlook" | "google" | null
+  provider_event_id?: string
+  provider_event_url?: string // uri
+  last_synced_at?: string // date-time
+  etag?: string
+}
+```