modulex-js 0.1.0

package/dist/index.js

@@ -0,0 +1,2224 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  BadRequestError: () => BadRequestError,
+  ConflictError: () => ConflictError,
+  ExternalServiceError: () => ExternalServiceError,
+  InternalError: () => InternalError,
+  Modulex: () => Modulex,
+  ModulexError: () => ModulexError,
+  NotFoundError: () => NotFoundError,
+  PermissionError: () => PermissionError,
+  RateLimitError: () => RateLimitError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  StreamError: () => StreamError,
+  TimeoutError: () => TimeoutError,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.modulex.dev";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+function resolveConfig(config) {
+  if (!config.apiKey) {
+    throw new Error("ModuleX API key is required. Pass `apiKey` to the Modulex constructor.");
+  }
+  return {
+    apiKey: config.apiKey,
+    organizationId: config.organizationId,
+    baseUrl: (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
+    timeout: config.timeout ?? DEFAULT_TIMEOUT,
+    maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+    fetch: config.fetch ?? globalThis.fetch
+  };
+}
+
+// src/errors.ts
+var ModulexError = class extends Error {
+  constructor(message, status, body, headers) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    this.name = "ModulexError";
+  }
+};
+var BadRequestError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 400, body, headers);
+    this.name = "BadRequestError";
+  }
+};
+var AuthenticationError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 401, body, headers);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 403, body, headers);
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 404, body, headers);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 409, body, headers);
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 422, body, headers);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 429, body, headers);
+    this.name = "RateLimitError";
+    const retryHeader = headers?.get("retry-after");
+    this.retryAfter = retryHeader ? Number(retryHeader) : void 0;
+  }
+};
+var InternalError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 500, body, headers);
+    this.name = "InternalError";
+  }
+};
+var ExternalServiceError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 502, body, headers);
+    this.name = "ExternalServiceError";
+  }
+};
+var ServiceUnavailableError = class extends ModulexError {
+  constructor(message, body, headers) {
+    super(message, 503, body, headers);
+    this.name = "ServiceUnavailableError";
+  }
+};
+var StreamError = class extends ModulexError {
+  constructor(message) {
+    super(message, void 0, void 0, void 0);
+    this.name = "StreamError";
+  }
+};
+var TimeoutError = class extends ModulexError {
+  constructor(message = "Request timed out") {
+    super(message, void 0, void 0, void 0);
+    this.name = "TimeoutError";
+  }
+};
+function createErrorFromStatus(status, body, headers) {
+  const message = extractErrorMessage(body, status);
+  switch (status) {
+    case 400:
+      return new BadRequestError(message, body, headers);
+    case 401:
+      return new AuthenticationError(message, body, headers);
+    case 403:
+      return new PermissionError(message, body, headers);
+    case 404:
+      return new NotFoundError(message, body, headers);
+    case 409:
+      return new ConflictError(message, body, headers);
+    case 422:
+      return new ValidationError(message, body, headers);
+    case 429:
+      return new RateLimitError(message, body, headers);
+    case 500:
+      return new InternalError(message, body, headers);
+    case 502:
+      return new ExternalServiceError(message, body, headers);
+    case 503:
+      return new ServiceUnavailableError(message, body, headers);
+    default:
+      return new ModulexError(message, status, body, headers);
+  }
+}
+function extractErrorMessage(body, status) {
+  if (body && typeof body === "object" && "detail" in body) {
+    const detail = body.detail;
+    if (typeof detail === "string") return detail;
+    if (Array.isArray(detail)) {
+      return detail.map((d) => `${d.loc?.join(".")}: ${d.msg}`).join("; ");
+    }
+  }
+  return `HTTP ${status} error`;
+}
+
+// src/streaming.ts
+async function* parseSSEStream(response, signal) {
+  const body = response.body;
+  if (!body) {
+    throw new StreamError("Response body is null \u2014 cannot read SSE stream");
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "";
+  let currentData = [];
+  let currentId;
+  let currentRetry;
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line === "" || line === "\r") {
+          if (currentData.length > 0) {
+            const dataStr = currentData.join("\n");
+            let parsedData;
+            try {
+              parsedData = JSON.parse(dataStr);
+            } catch {
+              parsedData = { raw: dataStr };
+            }
+            yield {
+              event: currentEvent || "message",
+              data: parsedData,
+              id: currentId,
+              retry: currentRetry
+            };
+          }
+          currentEvent = "";
+          currentData = [];
+          currentId = void 0;
+          currentRetry = void 0;
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colonIdx = line.indexOf(":");
+        let field;
+        let value_str;
+        if (colonIdx === -1) {
+          field = line;
+          value_str = "";
+        } else {
+          field = line.slice(0, colonIdx);
+          value_str = line.slice(colonIdx + 1);
+          if (value_str.startsWith(" ")) {
+            value_str = value_str.slice(1);
+          }
+        }
+        switch (field) {
+          case "event":
+            currentEvent = value_str;
+            break;
+          case "data":
+            currentData.push(value_str);
+            break;
+          case "id":
+            currentId = value_str;
+            break;
+          case "retry": {
+            const n = parseInt(value_str, 10);
+            if (!isNaN(n)) currentRetry = n;
+            break;
+          }
+        }
+      }
+    }
+    if (currentData.length > 0) {
+      const dataStr = currentData.join("\n");
+      let parsedData;
+      try {
+        parsedData = JSON.parse(dataStr);
+      } catch {
+        parsedData = { raw: dataStr };
+      }
+      yield {
+        event: currentEvent || "message",
+        data: parsedData,
+        id: currentId,
+        retry: currentRetry
+      };
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/base.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503]);
+var NON_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([400, 401, 403, 404, 409, 422]);
+function toSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function convertKeysToSnakeCase(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(convertKeysToSnakeCase);
+  if (typeof obj === "object" && !(obj instanceof Date) && !(obj instanceof Blob) && !(typeof File !== "undefined" && obj instanceof File)) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[toSnakeCase(key)] = convertKeysToSnakeCase(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var BaseResource = class {
+  constructor(config) {
+    this._config = config;
+  }
+  /**
+   * Resolve the organization ID from per-request options or client default.
+   * @internal
+   */
+  resolveOrgId(options) {
+    return options?.organizationId ?? this._config.organizationId;
+  }
+  /**
+   * Build full URL with query parameters.
+   * @internal
+   */
+  buildUrl(path, params) {
+    const url = new URL(`${this._config.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(toSnakeCase(key), String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Build headers for a request.
+   * @internal
+   */
+  buildHeaders(orgId, contentType) {
+    const headers = {
+      "Authorization": `Bearer ${this._config.apiKey}`
+    };
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    if (orgId) {
+      headers["X-Organization-ID"] = orgId;
+    }
+    return headers;
+  }
+  /**
+   * Create an abort signal that combines timeout and user-provided signal.
+   * @internal
+   */
+  createSignal(options) {
+    const timeout = options?.timeout ?? this._config.timeout;
+    const signals = [AbortSignal.timeout(timeout)];
+    if (options?.signal) {
+      signals.push(options.signal);
+    }
+    return AbortSignal.any(signals);
+  }
+  /**
+   * Execute a fetch request with retry logic.
+   * @internal
+   */
+  async fetchWithRetry(url, init, maxRetries) {
+    let lastError;
+    const attempts = maxRetries + 1;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        const response = await this._config.fetch(url, init);
+        if (response.ok) {
+          return response;
+        }
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          body = { detail: response.statusText };
+        }
+        const error = createErrorFromStatus(response.status, body, response.headers);
+        if (NON_RETRYABLE_STATUS_CODES.has(response.status)) {
+          throw error;
+        }
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < maxRetries) {
+          lastError = error;
+          const delay = this.calculateDelay(attempt, response.headers);
+          await this.sleep(delay, init.signal ?? void 0);
+          continue;
+        }
+        throw error;
+      } catch (e) {
+        if (e instanceof DOMException && e.name === "AbortError") {
+          throw new TimeoutError();
+        }
+        if (e instanceof DOMException && e.name === "TimeoutError") {
+          throw new TimeoutError();
+        }
+        if (e && typeof e === "object" && "status" in e) {
+          const status = e.status;
+          if (NON_RETRYABLE_STATUS_CODES.has(status)) throw e;
+        }
+        if (attempt < maxRetries) {
+          lastError = e instanceof Error ? e : new Error(String(e));
+          const delay = this.calculateDelay(attempt);
+          try {
+            await this.sleep(delay, init.signal ?? void 0);
+          } catch {
+            throw lastError;
+          }
+          continue;
+        }
+        throw e;
+      }
+    }
+    throw lastError ?? new Error("Request failed");
+  }
+  /**
+   * Calculate delay for exponential backoff with jitter.
+   * @internal
+   */
+  calculateDelay(attempt, headers) {
+    const retryAfter = headers?.get("retry-after");
+    if (retryAfter) {
+      const seconds = Number(retryAfter);
+      if (!isNaN(seconds)) return seconds * 1e3;
+    }
+    const base = 500;
+    const maxDelay = 3e4;
+    const exponential = base * Math.pow(2, attempt);
+    const jitter = Math.random() * base;
+    return Math.min(exponential + jitter, maxDelay);
+  }
+  /**
+   * Sleep for a given duration, respecting abort signals.
+   * @internal
+   */
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new TimeoutError());
+        return;
+      }
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new TimeoutError());
+      }, { once: true });
+    });
+  }
+  /** Perform a GET request. */
+  async _get(path, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const signal = this.createSignal(options);
+    const response = await this.fetchWithRetry(url, {
+      method: "GET",
+      headers: this.buildHeaders(orgId, "application/json"),
+      signal
+    }, this._config.maxRetries);
+    return response.json();
+  }
+  /** Perform a POST request. */
+  async _post(path, body, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const signal = this.createSignal(options);
+    const response = await this.fetchWithRetry(url, {
+      method: "POST",
+      headers: this.buildHeaders(orgId, "application/json"),
+      body: body !== void 0 ? JSON.stringify(convertKeysToSnakeCase(body)) : void 0,
+      signal
+    }, this._config.maxRetries);
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  /** Perform a PUT request. */
+  async _put(path, body, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const signal = this.createSignal(options);
+    const response = await this.fetchWithRetry(url, {
+      method: "PUT",
+      headers: this.buildHeaders(orgId, "application/json"),
+      body: body !== void 0 ? JSON.stringify(convertKeysToSnakeCase(body)) : void 0,
+      signal
+    }, this._config.maxRetries);
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  /** Perform a PATCH request. */
+  async _patch(path, body, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const signal = this.createSignal(options);
+    const response = await this.fetchWithRetry(url, {
+      method: "PATCH",
+      headers: this.buildHeaders(orgId, "application/json"),
+      body: body !== void 0 ? JSON.stringify(convertKeysToSnakeCase(body)) : void 0,
+      signal
+    }, this._config.maxRetries);
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  /** Perform a DELETE request. */
+  async _delete(path, body, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const signal = this.createSignal(options);
+    const response = await this.fetchWithRetry(url, {
+      method: "DELETE",
+      headers: this.buildHeaders(orgId, "application/json"),
+      body: body !== void 0 ? JSON.stringify(convertKeysToSnakeCase(body)) : void 0,
+      signal
+    }, this._config.maxRetries);
+    if (response.status === 204) return void 0;
+    const text = await response.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  /** Open an SSE stream and return an async iterable of events. */
+  async *streamSSE(path, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const response = await this._config.fetch(url, {
+      method: "GET",
+      headers: {
+        ...this.buildHeaders(orgId),
+        "Accept": "text/event-stream",
+        "Cache-Control": "no-cache"
+      },
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = { detail: response.statusText };
+      }
+      throw createErrorFromStatus(response.status, body, response.headers);
+    }
+    yield* parseSSEStream(response, options?.signal);
+  }
+  /** Perform a POST SSE stream request. */
+  async *streamSSEPost(path, body, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const response = await this._config.fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.buildHeaders(orgId, "application/json"),
+        "Accept": "text/event-stream"
+      },
+      body: body !== void 0 ? JSON.stringify(convertKeysToSnakeCase(body)) : void 0,
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { detail: response.statusText };
+      }
+      throw createErrorFromStatus(response.status, errorBody, response.headers);
+    }
+    yield* parseSSEStream(response, options?.signal);
+  }
+  /** Upload a file using multipart/form-data. */
+  async upload(path, formData, options) {
+    const orgId = this.resolveOrgId(options);
+    const url = this.buildUrl(path, options?.params);
+    const signal = this.createSignal(options);
+    const headers = this.buildHeaders(orgId);
+    const response = await this.fetchWithRetry(url, {
+      method: "POST",
+      headers,
+      body: formData,
+      signal
+    }, this._config.maxRetries);
+    return response.json();
+  }
+};
+
+// src/resources/auth.ts
+var Auth = class extends BaseResource {
+  /**
+   * GET /auth/me
+   *
+   * Returns the authenticated user's profile.
+   */
+  async me(options) {
+    return this._get("/auth/me", options);
+  }
+  /**
+   * GET /auth/me/organizations
+   *
+   * Returns the organizations the authenticated user belongs to.
+   */
+  async organizations(params, options) {
+    return this._get("/auth/me/organizations", {
+      ...options,
+      params: { ...options?.params, role: params?.role }
+    });
+  }
+  /**
+   * GET /auth/invitations/my
+   *
+   * Returns pending invitations for the authenticated user.
+   */
+  async invitations(options) {
+    return this._get("/auth/invitations/my", options);
+  }
+  /**
+   * POST /auth/invitations/{id}/accept
+   *
+   * Accepts a pending organization invitation.
+   */
+  async acceptInvitation(invitationId, options) {
+    return this._post(
+      `/auth/invitations/${invitationId}/accept`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /auth/invitations/{id}/reject
+   *
+   * Rejects a pending organization invitation.
+   */
+  async rejectInvitation(invitationId, options) {
+    return this._post(
+      `/auth/invitations/${invitationId}/reject`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /auth/organizations/leave
+   *
+   * Leaves the current organization (requires organization context).
+   */
+  async leaveOrganization(options) {
+    return this._post("/auth/organizations/leave", void 0, options);
+  }
+};
+
+// src/resources/api-keys.ts
+var ApiKeys = class extends BaseResource {
+  /**
+   * POST /api-keys
+   *
+   * Creates a new API key. The full key value is returned only once.
+   */
+  async create(params, options) {
+    return this._post("/api-keys", params, options);
+  }
+  /**
+   * GET /api-keys
+   *
+   * Lists all API keys for the authenticated user.
+   */
+  async list(params, options) {
+    return this._get("/api-keys", {
+      ...options,
+      params: {
+        ...options?.params,
+        include_revoked: params?.includeRevoked
+      }
+    });
+  }
+  /**
+   * GET /api-keys/{keyId}
+   *
+   * Returns details for a specific API key (masked — never the full key).
+   */
+  async get(keyId, options) {
+    return this._get(`/api-keys/${keyId}`, options);
+  }
+  /**
+   * DELETE /api-keys/{keyId}
+   *
+   * Permanently revokes an API key.
+   */
+  async revoke(keyId, options) {
+    return this._delete(`/api-keys/${keyId}`, void 0, options);
+  }
+};
+
+// src/resources/organizations.ts
+var Organizations = class extends BaseResource {
+  /**
+   * POST /organizations
+   *
+   * Creates a new organization. The authenticated user becomes the owner.
+   */
+  async create(params, options) {
+    return this._post("/organizations", params, options);
+  }
+  /**
+   * GET /organizations/llms
+   *
+   * Returns the LLM integrations configured for the current organization.
+   */
+  async llms(options) {
+    return this._get("/organizations/llms", options);
+  }
+  /**
+   * POST /organizations/invite
+   *
+   * Sends an invitation email to add a user to the current organization.
+   */
+  async invite(params, options) {
+    return this._post("/organizations/invite", params, options);
+  }
+  /**
+   * POST /organizations/invitations/{id}/cancel
+   *
+   * Cancels a pending organization invitation.
+   */
+  async cancelInvitation(invitationId, options) {
+    return this._post(
+      `/organizations/invitations/${invitationId}/cancel`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /organizations/invitations/{id}/reinvite
+   *
+   * Re-sends an invitation email for a pending invitation.
+   */
+  async reinvite(invitationId, options) {
+    return this._post(
+      `/organizations/invitations/${invitationId}/reinvite`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * PUT /organizations/{orgId}/users/{userId}/role
+   *
+   * Updates a member's role within an organization.
+   */
+  async updateRole(organizationId, userId, params, options) {
+    return this._put(
+      `/organizations/${organizationId}/users/${userId}/role`,
+      params,
+      options
+    );
+  }
+  /**
+   * DELETE /organizations/{orgId}/users/{userId}
+   *
+   * Removes a user from an organization. Requires owner permission.
+   */
+  async removeUser(organizationId, userId, options) {
+    return this._delete(
+      `/organizations/${organizationId}/users/${userId}`,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/workflows.ts
+var Workflows = class extends BaseResource {
+  /**
+   * POST /workflows
+   *
+   * Creates a new workflow with the given schema.
+   */
+  async create(params, options) {
+    return this._post("/workflows", params, options);
+  }
+  /**
+   * GET /workflows
+   *
+   * Lists workflows in the current organization.
+   */
+  async list(params, options) {
+    return this._get("/workflows", {
+      ...options,
+      params: {
+        ...options?.params,
+        status: params?.status,
+        category: params?.category,
+        visibility: params?.visibility,
+        search: params?.search,
+        page: params?.page,
+        page_size: params?.pageSize
+      }
+    });
+  }
+  /**
+   * Auto-pagination — yields all WorkflowSummary records across pages.
+   *
+   * Fetches page=1 with pageSize=100 and continues until all pages have been
+   * exhausted or there are no more results.
+   */
+  async *listAll(params, options) {
+    let page = 1;
+    const pageSize = 100;
+    while (true) {
+      const response = await this.list({ ...params, page, pageSize }, options);
+      for (const workflow of response.workflows) {
+        yield workflow;
+      }
+      const totalPages = response.total_pages ?? Math.ceil(response.total / pageSize);
+      if (page >= totalPages || response.workflows.length === 0) {
+        break;
+      }
+      page++;
+    }
+  }
+  /**
+   * GET /workflows/{workflowId}
+   *
+   * Returns a full workflow object including the stored schema.
+   */
+  async get(workflowId, options) {
+    return this._get(`/workflows/${workflowId}`, options);
+  }
+  /**
+   * PUT /workflows/{workflowId}
+   *
+   * Updates an existing workflow. Only provided fields are changed.
+   */
+  async update(workflowId, params, options) {
+    return this._put(`/workflows/${workflowId}`, params, options);
+  }
+  /**
+   * DELETE /workflows/{workflowId}
+   *
+   * Soft-deletes a workflow.
+   */
+  async delete(workflowId, options) {
+    return this._delete(
+      `/workflows/${workflowId}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /workflows/builder/details
+   *
+   * Returns available node types, integration categories, and counts for
+   * the visual workflow builder. Results are cached for 60 minutes.
+   */
+  async builderDetails(params, options) {
+    return this._get("/workflows/builder/details", {
+      ...options,
+      params: {
+        ...options?.params,
+        node_type: params?.nodeType,
+        category: params?.category,
+        integration_name: params?.integrationName
+      }
+    });
+  }
+};
+
+// src/resources/executions.ts
+var Executions = class extends BaseResource {
+  /**
+   * POST /workflows/run
+   *
+   * Initiates a workflow run. Supports four modes: existing workflow, ad-hoc
+   * workflow, direct LLM call, and system workflow. Returns immediately with
+   * run metadata; stream events via `listen()`.
+   */
+  async run(params, options) {
+    return this._post("/workflows/run", params, options);
+  }
+  /**
+   * GET /workflows/state/{threadId}
+   *
+   * Returns the persisted state snapshot of a workflow thread at its latest
+   * checkpoint.
+   */
+  async getState(threadId, options) {
+    return this._get(`/workflows/state/${threadId}`, options);
+  }
+  /**
+   * POST /workflows/resume/{threadId}
+   *
+   * Resumes a workflow that is waiting at an interrupt node.
+   */
+  async resume(params, options) {
+    const { threadId, ...rest } = params;
+    return this._post(
+      `/workflows/resume/${threadId}`,
+      rest,
+      options
+    );
+  }
+  /**
+   * POST /workflows/cancel/{runId}
+   *
+   * Requests cancellation of an in-progress workflow run.
+   */
+  async cancel(runId, params, options) {
+    return this._post(
+      `/workflows/cancel/${runId}`,
+      params ?? {},
+      options
+    );
+  }
+  /**
+   * GET /workflows/listen/{runId} — SSE stream
+   *
+   * Opens a Server-Sent Events stream for real-time execution events of
+   * an in-progress workflow run. Yields typed `WorkflowSSEEvent` values.
+   */
+  listen(runId, options) {
+    return this.streamSSE(
+      `/workflows/listen/${runId}`,
+      options
+    );
+  }
+};
+
+// src/resources/deployments.ts
+var Deployments = class extends BaseResource {
+  /**
+   * POST /workflows/{workflowId}/deploy
+   *
+   * Creates a new deployment snapshot of a workflow.
+   */
+  async create(workflowId, params, options) {
+    return this._post(
+      `/workflows/${workflowId}/deploy`,
+      params ?? {},
+      options
+    );
+  }
+  /**
+   * GET /workflows/{workflowId}/deployments
+   *
+   * Lists deployment snapshots for a workflow.
+   */
+  async list(workflowId, params, options) {
+    return this._get(
+      `/workflows/${workflowId}/deployments`,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          limit: params?.limit,
+          offset: params?.offset
+        }
+      }
+    );
+  }
+  /**
+   * GET /workflows/{workflowId}/deployments/{deploymentId}
+   *
+   * Returns the full deployment record including the stored workflow schema.
+   */
+  async get(workflowId, deploymentId, options) {
+    return this._get(
+      `/workflows/${workflowId}/deployments/${deploymentId}`,
+      options
+    );
+  }
+  /**
+   * PUT /workflows/{workflowId}/deployments/{deploymentId}/activate
+   *
+   * Sets the given deployment as the live (active) version for the workflow.
+   */
+  async activate(workflowId, deploymentId, options) {
+    return this._put(
+      `/workflows/${workflowId}/deployments/${deploymentId}/activate`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * DELETE /workflows/{workflowId}/deployments/live
+   *
+   * Deactivates the currently live deployment so no version is active.
+   */
+  async deactivate(workflowId, options) {
+    return this._delete(
+      `/workflows/${workflowId}/deployments/live`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * DELETE /workflows/{workflowId}/deployments/{deploymentId}
+   *
+   * Permanently deletes a deployment snapshot.
+   */
+  async delete(workflowId, deploymentId, options) {
+    return this._delete(
+      `/workflows/${workflowId}/deployments/${deploymentId}`,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/chats.ts
+var Chats = class extends BaseResource {
+  /**
+   * GET /chats
+   *
+   * Returns all chats for the current organization, grouped by folder.
+   * Keys include at minimum `"chats"`, `"pinned"`, and `"archived"`.
+   */
+  async list(options) {
+    return this._get("/chats", options);
+  }
+  /**
+   * GET /chats/stream — SSE
+   *
+   * Opens a Server-Sent Events stream for real-time chat list updates.
+   * Emits `connected`, `chat_list_updated`, and `keepalive` events.
+   */
+  stream(options) {
+    return this.streamSSE("/chats/stream", options);
+  }
+  /**
+   * GET /chats/{chatId}
+   *
+   * Returns a single chat session with its embedded messages.
+   */
+  async get(chatId, options) {
+    return this._get(`/chats/${chatId}`, options);
+  }
+  /**
+   * GET /chats/{chatId}/messages
+   *
+   * Returns paginated messages for a chat session.
+   */
+  async messages(chatId, params, options) {
+    return this._get(`/chats/${chatId}/messages`, {
+      ...options,
+      params: {
+        ...options?.params,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * PATCH /chats/{chatId}
+   *
+   * Updates a chat's title, privacy, or folder assignment.
+   */
+  async update(chatId, params, options) {
+    return this._patch(`/chats/${chatId}`, params, options);
+  }
+  /**
+   * DELETE /chats/{chatId}
+   *
+   * Soft-deletes a chat. Private chats can only be deleted by the creator.
+   */
+  async delete(chatId, options) {
+    return this._delete(`/chats/${chatId}`, void 0, options);
+  }
+};
+
+// src/resources/credentials.ts
+var Credentials = class extends BaseResource {
+  /**
+   * GET /credentials
+   *
+   * Lists credentials for the current organization.
+   * Returns a grouped response by default, or a flat list when
+   * `integrationName` is specified.
+   */
+  async list(params, options) {
+    return this._get("/credentials", {
+      ...options,
+      params: {
+        ...options?.params,
+        integration_name: params?.integrationName,
+        auth_type: params?.authType,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * GET /credentials/{credentialId}
+   *
+   * Returns a single credential record.
+   */
+  async get(credentialId, params, options) {
+    return this._get(`/credentials/${credentialId}`, {
+      ...options,
+      params: {
+        ...options?.params,
+        include_masked: params?.includeMasked
+      }
+    });
+  }
+  /**
+   * POST /credentials
+   *
+   * Creates a new credential. The auth data is encrypted at rest.
+   */
+  async create(params, options) {
+    return this._post("/credentials", params, options);
+  }
+  /**
+   * PUT /credentials/{credentialId}
+   *
+   * Updates a credential's display name or metadata.
+   */
+  async update(credentialId, params, options) {
+    return this._put(`/credentials/${credentialId}`, params, options);
+  }
+  /**
+   * DELETE /credentials/{credentialId}
+   *
+   * Permanently deletes a credential. Returns 204 No Content on success.
+   */
+  async delete(credentialId, options) {
+    return this._delete(`/credentials/${credentialId}`, void 0, options);
+  }
+  /**
+   * POST /credentials/{credentialId}/set-default
+   *
+   * Sets the credential as the default for its integration.
+   * Unsets any previously set default.
+   */
+  async setDefault(credentialId, options) {
+    return this._post(
+      `/credentials/${credentialId}/set-default`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /credentials/test-temporary
+   *
+   * Validates a credential's auth data without saving it.
+   */
+  async testTemporary(params, options) {
+    return this._post(
+      "/credentials/test-temporary",
+      params,
+      options
+    );
+  }
+  /**
+   * POST /credentials/{credentialId}/test
+   *
+   * Tests an existing saved credential by making a live API call.
+   */
+  async test(credentialId, options) {
+    return this._post(
+      `/credentials/${credentialId}/test`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /credentials/{credentialId}/usage
+   *
+   * Returns usage statistics for a credential.
+   */
+  async usage(credentialId, params, options) {
+    return this._get(`/credentials/${credentialId}/usage`, {
+      ...options,
+      params: {
+        ...options?.params,
+        start_date: params?.startDate,
+        end_date: params?.endDate
+      }
+    });
+  }
+  /**
+   * GET /credentials/{credentialId}/audit
+   *
+   * Returns the audit log for a credential.
+   */
+  async audit(credentialId, params, options) {
+    return this._get(`/credentials/${credentialId}/audit`, {
+      ...options,
+      params: {
+        ...options?.params,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * POST /credentials/bulk-modulex-keys/stream — SSE
+   *
+   * Streams bulk ModuleX managed key provisioning events.
+   */
+  bulkModulexKeys(options) {
+    return this.streamSSEPost("/credentials/bulk-modulex-keys/stream", void 0, options);
+  }
+  /**
+   * POST /credentials/mcp-server
+   *
+   * Creates a credential for a Model Context Protocol (MCP) server.
+   */
+  async mcpServer(params, options) {
+    return this._post("/credentials/mcp-server", params, options);
+  }
+  /**
+   * POST /credentials/{credentialId}/refresh-discovery
+   *
+   * Refreshes the tool discovery cache for an MCP server credential.
+   */
+  async refreshDiscovery(credentialId, options) {
+    return this._post(
+      `/credentials/${credentialId}/refresh-discovery`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /credentials/{credentialId}/mcp-tools
+   *
+   * Returns the tools discovered from an MCP server credential.
+   */
+  async mcpTools(credentialId, options) {
+    return this._get(
+      `/credentials/${credentialId}/mcp-tools`,
+      options
+    );
+  }
+};
+
+// src/resources/integrations.ts
+var Integrations = class extends BaseResource {
+  /**
+   * GET /integrations/browse
+   *
+   * Returns the integration catalog, optionally filtered by category or type.
+   */
+  async browse(params, options) {
+    return this._get("/integrations/browse", {
+      ...options,
+      params: {
+        ...options?.params,
+        category: params?.category,
+        type: params?.type,
+        auth_type: params?.authType,
+        search: params?.search,
+        include_details: params?.includeDetails,
+        paginate: params?.paginate,
+        page: params?.page,
+        page_size: params?.pageSize
+      }
+    });
+  }
+  /**
+   * GET /integrations/tools
+   *
+   * Returns all available tool integrations, optionally filtered by category.
+   */
+  async tools(params, options) {
+    return this._get("/integrations/tools", {
+      ...options,
+      params: { ...options?.params, category: params?.category }
+    });
+  }
+  /**
+   * GET /integrations/tools/{integrationName}
+   *
+   * Returns the full detail for a specific tool integration including its actions.
+   */
+  async tool(integrationName, options) {
+    return this._get(
+      `/integrations/tools/${integrationName}`,
+      options
+    );
+  }
+  /**
+   * GET /integrations/llm-providers
+   *
+   * Returns all available LLM provider integrations, optionally filtered by category.
+   */
+  async llmProviders(params, options) {
+    return this._get("/integrations/llm-providers", {
+      ...options,
+      params: { ...options?.params, category: params?.category }
+    });
+  }
+  /**
+   * GET /integrations/llm-providers/{providerName}
+   *
+   * Returns the full detail for a specific LLM provider including available models.
+   */
+  async llmProvider(providerName, options) {
+    return this._get(
+      `/integrations/llm-providers/${providerName}`,
+      options
+    );
+  }
+  /**
+   * GET /integrations/knowledge-providers
+   *
+   * Returns all available knowledge provider integrations.
+   */
+  async knowledgeProviders(params, options) {
+    return this._get("/integrations/knowledge-providers", {
+      ...options,
+      params: { ...options?.params, category: params?.category }
+    });
+  }
+  /**
+   * GET /integrations/knowledge-providers/{providerName}
+   *
+   * Returns the full detail for a specific knowledge provider.
+   */
+  async knowledgeProvider(providerName, options) {
+    return this._get(
+      `/integrations/knowledge-providers/${providerName}`,
+      options
+    );
+  }
+  /**
+   * GET /integrations/{integrationName}
+   *
+   * Returns the detail object for any integration by name.
+   */
+  async get(integrationName, options) {
+    return this._get(
+      `/integrations/${integrationName}`,
+      options
+    );
+  }
+};
+
+// src/resources/knowledge.ts
+var Knowledge = class extends BaseResource {
+  /**
+   * GET /knowledge-bases
+   *
+   * Lists knowledge bases for the current organization.
+   */
+  async list(params, options) {
+    return this._get("/knowledge-bases", {
+      ...options,
+      params: {
+        ...options?.params,
+        status: params?.status,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * POST /knowledge-bases
+   *
+   * Creates a new knowledge base.
+   */
+  async create(params, options) {
+    return this._post("/knowledge-bases", params, options);
+  }
+  /**
+   * GET /knowledge-bases/stats
+   *
+   * Returns aggregated statistics across all knowledge bases in the organization.
+   */
+  async stats(options) {
+    return this._get("/knowledge-bases/stats", options);
+  }
+  /**
+   * GET /knowledge-bases/{kbId}
+   *
+   * Returns a single knowledge base record.
+   */
+  async get(knowledgeBaseId, options) {
+    return this._get(
+      `/knowledge-bases/${knowledgeBaseId}`,
+      options
+    );
+  }
+  /**
+   * PUT /knowledge-bases/{kbId}
+   *
+   * Updates a knowledge base's name, description, or configuration.
+   */
+  async update(knowledgeBaseId, params, options) {
+    return this._put(
+      `/knowledge-bases/${knowledgeBaseId}`,
+      params,
+      options
+    );
+  }
+  /**
+   * DELETE /knowledge-bases/{kbId}
+   *
+   * Deletes a knowledge base. Pass `deleteFiles: true` to also remove
+   * the underlying stored files.
+   */
+  async delete(knowledgeBaseId, params, options) {
+    return this._delete(
+      `/knowledge-bases/${knowledgeBaseId}`,
+      void 0,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          delete_files: params?.deleteFiles
+        }
+      }
+    );
+  }
+  /**
+   * POST /knowledge-bases/{kbId}/archive
+   *
+   * Archives a knowledge base, pausing ingestion without deleting data.
+   */
+  async archive(knowledgeBaseId, options) {
+    return this._post(
+      `/knowledge-bases/${knowledgeBaseId}/archive`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /knowledge-bases/{kbId}/documents
+   *
+   * Returns documents within a knowledge base.
+   */
+  async documents(knowledgeBaseId, params, options) {
+    return this._get(
+      `/knowledge-bases/${knowledgeBaseId}/documents`,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          status: params?.status,
+          limit: params?.limit,
+          offset: params?.offset
+        }
+      }
+    );
+  }
+  /**
+   * POST /knowledge-bases/{kbId}/documents — multipart upload
+   *
+   * Uploads a document file to a knowledge base for ingestion.
+   * Builds a `FormData` with the file and optional metadata JSON.
+   */
+  async uploadDocument(knowledgeBaseId, params, options) {
+    const formData = new FormData();
+    formData.append("file", params.file, params.filename);
+    if (params.metadata) {
+      formData.append("metadata", JSON.stringify(params.metadata));
+    }
+    return this.upload(
+      `/knowledge-bases/${knowledgeBaseId}/documents`,
+      formData,
+      options
+    );
+  }
+  /**
+   * GET /knowledge-bases/{kbId}/documents/{docId}
+   *
+   * Returns a single document record.
+   */
+  async getDocument(knowledgeBaseId, documentId, options) {
+    return this._get(
+      `/knowledge-bases/${knowledgeBaseId}/documents/${documentId}`,
+      options
+    );
+  }
+  /**
+   * GET /knowledge-bases/{kbId}/documents/{docId}/status
+   *
+   * Returns the processing status and progress of a document.
+   */
+  async documentStatus(knowledgeBaseId, documentId, options) {
+    return this._get(
+      `/knowledge-bases/${knowledgeBaseId}/documents/${documentId}/status`,
+      options
+    );
+  }
+  /**
+   * DELETE /knowledge-bases/{kbId}/documents/{docId}
+   *
+   * Deletes a document and its chunks from the knowledge base.
+   * Pass `deleteFile: true` to also remove the source file from storage.
+   */
+  async deleteDocument(knowledgeBaseId, documentId, params, options) {
+    return this._delete(
+      `/knowledge-bases/${knowledgeBaseId}/documents/${documentId}`,
+      void 0,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          delete_file: params?.deleteFile
+        }
+      }
+    );
+  }
+  /**
+   * POST /knowledge-bases/{kbId}/documents/{docId}/retry
+   *
+   * Retries ingestion of a failed document.
+   */
+  async retryDocument(knowledgeBaseId, documentId, options) {
+    return this._post(
+      `/knowledge-bases/${knowledgeBaseId}/documents/${documentId}/retry`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /knowledge-bases/{kbId}/documents/{docId}/chunks
+   *
+   * Returns the processed chunks for a document.
+   */
+  async documentChunks(knowledgeBaseId, documentId, params, options) {
+    return this._get(
+      `/knowledge-bases/${knowledgeBaseId}/documents/${documentId}/chunks`,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          limit: params?.limit,
+          offset: params?.offset
+        }
+      }
+    );
+  }
+  /**
+   * POST /knowledge-bases/{kbId}/search
+   *
+   * Performs a semantic search within a single knowledge base.
+   */
+  async search(knowledgeBaseId, params, options) {
+    return this._post(
+      `/knowledge-bases/${knowledgeBaseId}/search`,
+      params,
+      options
+    );
+  }
+  /**
+   * POST /knowledge-bases/search
+   *
+   * Searches across multiple knowledge bases simultaneously.
+   */
+  async searchMultiple(params, options) {
+    return this._post("/knowledge-bases/search", params, options);
+  }
+  /**
+   * POST /knowledge-bases/{kbId}/hybrid-search
+   *
+   * Performs a hybrid (semantic + keyword) search within a knowledge base.
+   */
+  async hybridSearch(knowledgeBaseId, params, options) {
+    return this._post(
+      `/knowledge-bases/${knowledgeBaseId}/hybrid-search`,
+      params,
+      options
+    );
+  }
+  /**
+   * POST /knowledge-bases/{kbId}/retrieve-context
+   *
+   * Retrieves a pre-formatted context string from a knowledge base for
+   * prompt injection.
+   */
+  async retrieveContext(knowledgeBaseId, params, options) {
+    return this._post(
+      `/knowledge-bases/${knowledgeBaseId}/retrieve-context`,
+      params,
+      options
+    );
+  }
+  /**
+   * GET /knowledge-bases/info/supported-file-types
+   *
+   * Returns the list of file types accepted by the document ingestion pipeline.
+   */
+  async supportedFileTypes(options) {
+    return this._get(
+      "/knowledge-bases/info/supported-file-types",
+      options
+    );
+  }
+};
+
+// src/resources/schedules.ts
+var Schedules = class extends BaseResource {
+  /**
+   * POST /schedules
+   *
+   * Creates a new workflow schedule.
+   */
+  async create(params, options) {
+    return this._post("/schedules", params, options);
+  }
+  /**
+   * GET /schedules
+   *
+   * Lists schedules for the current organization.
+   */
+  async list(params, options) {
+    return this._get("/schedules", {
+      ...options,
+      params: {
+        ...options?.params,
+        workflow_id: params?.workflowId,
+        is_active: params?.isActive,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * GET /schedules/{scheduleId}
+   *
+   * Returns a single schedule record.
+   */
+  async get(scheduleId, options) {
+    return this._get(`/schedules/${scheduleId}`, options);
+  }
+  /**
+   * PUT /schedules/{scheduleId}
+   *
+   * Updates an existing schedule. Only provided fields are changed.
+   */
+  async update(scheduleId, params, options) {
+    return this._put(`/schedules/${scheduleId}`, params, options);
+  }
+  /**
+   * DELETE /schedules/{scheduleId}
+   *
+   * Deletes a schedule and cancels all pending executions.
+   */
+  async delete(scheduleId, options) {
+    return this._delete(
+      `/schedules/${scheduleId}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /schedules/{scheduleId}/pause
+   *
+   * Pauses a schedule, preventing future runs until resumed.
+   */
+  async pause(scheduleId, options) {
+    return this._post(
+      `/schedules/${scheduleId}/pause`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /schedules/{scheduleId}/resume
+   *
+   * Resumes a paused schedule.
+   */
+  async resume(scheduleId, options) {
+    return this._post(
+      `/schedules/${scheduleId}/resume`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /schedules/{scheduleId}/runs
+   *
+   * Returns the run history for a schedule.
+   */
+  async runs(scheduleId, params, options) {
+    return this._get(`/schedules/${scheduleId}/runs`, {
+      ...options,
+      params: {
+        ...options?.params,
+        status: params?.status,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * GET /schedules/{scheduleId}/runs/stats
+   *
+   * Returns aggregate run statistics for a schedule.
+   */
+  async runStats(scheduleId, params, options) {
+    return this._get(
+      `/schedules/${scheduleId}/runs/stats`,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          days: params?.days
+        }
+      }
+    );
+  }
+  /**
+   * GET /schedules/{scheduleId}/runs/{runId}
+   *
+   * Returns details for a single scheduled run.
+   */
+  async getRun(scheduleId, runId, options) {
+    return this._get(
+      `/schedules/${scheduleId}/runs/${runId}`,
+      options
+    );
+  }
+  /**
+   * POST /schedules/{scheduleId}/runs/{runId}/retry
+   *
+   * Retries a failed scheduled run.
+   */
+  async retryRun(scheduleId, runId, options) {
+    return this._post(
+      `/schedules/${scheduleId}/runs/${runId}/retry`,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/templates.ts
+var Templates = class extends BaseResource {
+  /**
+   * GET /templates
+   *
+   * Returns the public template library.
+   */
+  async list(options) {
+    return this._get("/templates", options);
+  }
+  /**
+   * GET /templates/{templateId}
+   *
+   * Returns a single template including its full workflow schema.
+   */
+  async get(templateId, options) {
+    return this._get(`/templates/${templateId}`, options);
+  }
+  /**
+   * GET /templates/me
+   *
+   * Returns templates created by the authenticated user.
+   */
+  async mine(options) {
+    return this._get("/templates/me", options);
+  }
+  /**
+   * POST /templates
+   *
+   * Publishes a workflow as a new template.
+   */
+  async create(params, options) {
+    return this._post("/templates", params, options);
+  }
+  /**
+   * POST /templates/{templateId}/like
+   *
+   * Toggles the authenticated user's like on a template.
+   */
+  async like(templateId, options) {
+    return this._post(
+      `/templates/${templateId}/like`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /templates/{templateId}/use
+   *
+   * Imports a template as a new workflow in the current organization.
+   */
+  async use(templateId, options) {
+    return this._post(
+      `/templates/${templateId}/use`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /templates/{templateId}/update-request
+   *
+   * Submits an update request for a published template.
+   */
+  async updateRequest(templateId, params, options) {
+    return this._post(
+      `/templates/${templateId}/update-request`,
+      params,
+      options
+    );
+  }
+  /**
+   * POST /templates/creators
+   *
+   * Creates or updates the authenticated user's template creator profile.
+   */
+  async createCreator(params, options) {
+    return this._post("/templates/creators", params, options);
+  }
+  /**
+   * GET /templates/creators/me
+   *
+   * Returns the authenticated user's template creator profile.
+   */
+  async getCreator(options) {
+    return this._get("/templates/creators/me", options);
+  }
+};
+
+// src/resources/composer.ts
+var Composer = class extends BaseResource {
+  /**
+   * POST /composer/chat
+   *
+   * Starts a new Composer chat or sends a message to an existing session.
+   * Returns a run ID that can be used to listen to the SSE stream.
+   */
+  async chat(params, options) {
+    return this._post("/composer/chat", params, options);
+  }
+  /**
+   * GET /composer/chat/{composerChatId}
+   *
+   * Returns a Composer chat session with its messages and workflow snapshot status.
+   */
+  async get(composerChatId, options) {
+    return this._get(
+      `/composer/chat/${composerChatId}`,
+      options
+    );
+  }
+  /**
+   * GET /composer/chat/{composerChatId}/listen/{runId} — SSE
+   *
+   * Opens a Server-Sent Events stream for real-time Composer output during a run.
+   */
+  listen(composerChatId, runId, options) {
+    return this.streamSSE(
+      `/composer/chat/${composerChatId}/listen/${runId}`,
+      options
+    );
+  }
+  /**
+   * POST /composer/chat/{composerChatId}/save
+   *
+   * Saves the Composer's current workflow changes to the associated workflow.
+   */
+  async save(composerChatId, options) {
+    return this._post(
+      `/composer/chat/${composerChatId}/save`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * POST /composer/chat/{composerChatId}/revert
+   *
+   * Reverts the Composer's pending changes, restoring the last saved state.
+   */
+  async revert(composerChatId, options) {
+    return this._post(
+      `/composer/chat/${composerChatId}/revert`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * GET /composer/chat/workflow/{workflowId}/history
+   *
+   * Returns the Composer chat history associated with a workflow.
+   */
+  async history(workflowId, params, options) {
+    return this._get(
+      `/composer/chat/workflow/${workflowId}/history`,
+      {
+        ...options,
+        params: {
+          ...options?.params,
+          limit: params?.limit
+        }
+      }
+    );
+  }
+  /**
+   * DELETE /composer/chat/{composerChatId}
+   *
+   * Deletes a Composer chat session. Pass `permanent: true` to also delete
+   * the associated workflow.
+   */
+  async delete(composerChatId, params, options) {
+    return this._delete(
+      `/composer/chat/${composerChatId}`,
+      params,
+      options
+    );
+  }
+  /**
+   * GET /composer/chat/{composerChatId}/status
+   *
+   * Returns the real-time status of a Composer chat session.
+   */
+  async status(composerChatId, options) {
+    return this._get(
+      `/composer/chat/${composerChatId}/status`,
+      options
+    );
+  }
+  /**
+   * POST /composer/chat/{composerChatId}/cancel
+   *
+   * Cancels the in-progress run for a Composer chat session.
+   */
+  async cancel(composerChatId, options) {
+    return this._post(
+      `/composer/chat/${composerChatId}/cancel`,
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/dashboard.ts
+var Dashboard = class extends BaseResource {
+  /**
+   * GET /dashboard/logs
+   *
+   * Returns paginated activity logs for the current organization.
+   */
+  async logs(params, options) {
+    return this._get("/dashboard/logs", {
+      ...options,
+      params: {
+        ...options?.params,
+        limit: params?.limit,
+        offset: params?.offset,
+        category: params?.category,
+        operation: params?.operation,
+        start_date: params?.startDate,
+        end_date: params?.endDate
+      }
+    });
+  }
+  /**
+   * GET /dashboard/analytics/overview
+   *
+   * Returns high-level execution and usage analytics for the organization.
+   */
+  async analyticsOverview(params, options) {
+    return this._get("/dashboard/analytics/overview", {
+      ...options,
+      params: {
+        ...options?.params,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * GET /dashboard/analytics/tools
+   *
+   * Returns tool-usage analytics broken down by integration.
+   */
+  async analyticsTools(params, options) {
+    return this._get("/dashboard/analytics/tools", {
+      ...options,
+      params: {
+        ...options?.params,
+        period: params?.period,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * GET /dashboard/analytics/llm-usage
+   *
+   * Returns LLM token-usage analytics broken down by model and provider.
+   */
+  async analyticsLlmUsage(params, options) {
+    return this._get("/dashboard/analytics/llm-usage", {
+      ...options,
+      params: {
+        ...options?.params,
+        period: params?.period,
+        limit: params?.limit,
+        offset: params?.offset
+      }
+    });
+  }
+  /**
+   * GET /dashboard/users
+   *
+   * Returns organization members with pagination and search support.
+   */
+  async users(params, options) {
+    return this._get("/dashboard/users", {
+      ...options,
+      params: {
+        ...options?.params,
+        search: params?.search,
+        status: params?.status,
+        sort_by: params?.sortBy,
+        order: params?.order,
+        page: params?.page,
+        limit: params?.limit
+      }
+    });
+  }
+};
+
+// src/resources/subscriptions.ts
+var Subscriptions = class extends BaseResource {
+  /**
+   * GET /subscriptions/organization-plans
+   *
+   * Returns the list of available organization subscription plans.
+   */
+  async organizationPlans(options) {
+    return this._get(
+      "/subscriptions/organization-plans",
+      options
+    );
+  }
+  /**
+   * GET /subscriptions/organization-billing
+   *
+   * Returns the current organization's billing status and active subscription.
+   */
+  async billing(options) {
+    return this._get("/subscriptions/organization-billing", options);
+  }
+  /**
+   * POST /subscriptions/checkout-link
+   *
+   * Creates a Stripe Checkout session and returns the redirect URL.
+   */
+  async checkoutLink(params, options) {
+    return this._post(
+      "/subscriptions/checkout-link",
+      params,
+      options
+    );
+  }
+  /**
+   * POST /subscriptions/customer-portal
+   *
+   * Creates a Stripe Customer Portal session and returns the redirect URL
+   * for the user to manage their billing.
+   */
+  async customerPortal(options) {
+    return this._post(
+      "/subscriptions/customer-portal",
+      void 0,
+      options
+    );
+  }
+};
+
+// src/resources/notifications.ts
+var Notifications = class extends BaseResource {
+  /**
+   * GET /notifications
+   *
+   * Returns notifications for the current organization.
+   */
+  async list(options) {
+    return this._get("/notifications", options);
+  }
+  /**
+   * POST /notifications/organization
+   *
+   * Creates a new notification for the organization or a specific user.
+   */
+  async create(params, options) {
+    return this._post(
+      "/notifications/organization",
+      params,
+      options
+    );
+  }
+};
+
+// src/resources/system.ts
+var System = class extends BaseResource {
+  /**
+   * GET /system/health
+   *
+   * Returns the service health status, name, and version.
+   */
+  async health(options) {
+    return this._get(
+      "/system/health",
+      options
+    );
+  }
+  /**
+   * GET /system/metrics
+   *
+   * Returns Prometheus-format metrics as plain text.
+   * This endpoint bypasses the JSON-parsing logic of `BaseResource.get()` and
+   * reads the raw response body as a string.
+   */
+  async metrics(options) {
+    const orgId = options?.organizationId ?? this._config.organizationId;
+    const url = `${this._config.baseUrl}/system/metrics`;
+    const headers = {
+      "Authorization": `Bearer ${this._config.apiKey}`
+    };
+    if (orgId) {
+      headers["X-Organization-ID"] = orgId;
+    }
+    const response = await this._config.fetch(url, {
+      method: "GET",
+      headers,
+      signal: options?.signal
+    });
+    return response.text();
+  }
+  /**
+   * GET /system/timezones
+   *
+   * Returns the list of supported IANA timezone identifiers.
+   */
+  async timezones(options) {
+    return this._get("/system/timezones", options);
+  }
+  /**
+   * GET /system/timezones/search
+   *
+   * Searches supported IANA timezone identifiers by query string.
+   */
+  async searchTimezones(query, options) {
+    return this._get("/system/timezones/search", {
+      ...options,
+      params: { ...options?.params, q: query }
+    });
+  }
+};
+
+// src/client.ts
+var Modulex = class {
+  constructor(config) {
+    this._config = resolveConfig(config);
+  }
+  /** Authentication and user profile endpoints. */
+  get auth() {
+    return this._auth ?? (this._auth = new Auth(this._config));
+  }
+  /** API key management endpoints. */
+  get apiKeys() {
+    return this._apiKeys ?? (this._apiKeys = new ApiKeys(this._config));
+  }
+  /** Organization management endpoints. */
+  get organizations() {
+    return this._organizations ?? (this._organizations = new Organizations(this._config));
+  }
+  /** Workflow CRUD endpoints. */
+  get workflows() {
+    return this._workflows ?? (this._workflows = new Workflows(this._config));
+  }
+  /** Workflow execution endpoints (run, resume, cancel, listen). */
+  get executions() {
+    return this._executions ?? (this._executions = new Executions(this._config));
+  }
+  /** Workflow deployment endpoints. */
+  get deployments() {
+    return this._deployments ?? (this._deployments = new Deployments(this._config));
+  }
+  /** Chat endpoints. */
+  get chats() {
+    return this._chats ?? (this._chats = new Chats(this._config));
+  }
+  /** Credential management endpoints. */
+  get credentials() {
+    return this._credentials ?? (this._credentials = new Credentials(this._config));
+  }
+  /** Integration browsing endpoints. */
+  get integrations() {
+    return this._integrations ?? (this._integrations = new Integrations(this._config));
+  }
+  /** Knowledge base endpoints. */
+  get knowledge() {
+    return this._knowledge ?? (this._knowledge = new Knowledge(this._config));
+  }
+  /** Schedule management endpoints. */
+  get schedules() {
+    return this._schedules ?? (this._schedules = new Schedules(this._config));
+  }
+  /** Template endpoints. */
+  get templates() {
+    return this._templates ?? (this._templates = new Templates(this._config));
+  }
+  /** Composer (AI workflow builder) endpoints. */
+  get composer() {
+    return this._composer ?? (this._composer = new Composer(this._config));
+  }
+  /** Dashboard and analytics endpoints. */
+  get dashboard() {
+    return this._dashboard ?? (this._dashboard = new Dashboard(this._config));
+  }
+  /** Subscription and billing endpoints. */
+  get subscriptions() {
+    return this._subscriptions ?? (this._subscriptions = new Subscriptions(this._config));
+  }
+  /** Notification endpoints. */
+  get notifications() {
+    return this._notifications ?? (this._notifications = new Notifications(this._config));
+  }
+  /** System health and utility endpoints. */
+  get system() {
+    return this._system ?? (this._system = new System(this._config));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  BadRequestError,
+  ConflictError,
+  ExternalServiceError,
+  InternalError,
+  Modulex,
+  ModulexError,
+  NotFoundError,
+  PermissionError,
+  RateLimitError,
+  ServiceUnavailableError,
+  StreamError,
+  TimeoutError,
+  ValidationError
+});