@bimpeai/sdk 0.0.0-beta-20260606071952

package/dist/index.cjs

@@ -0,0 +1,803 @@
+'use strict';
+
+// src/version.ts
+var VERSION = "0.0.0-beta-20260606071952";
+
+// src/core/envelope.ts
+function unwrapEnvelope(body) {
+  if (!isEnvelope(body)) {
+    throw new TypeError("Response is not a BimpeAI envelope (missing `message` field)");
+  }
+  return {
+    data: body.data,
+    meta: body.meta ?? null
+  };
+}
+function isEnvelope(value) {
+  return typeof value === "object" && value !== null && "message" in value && typeof value.message === "string";
+}
+
+// src/core/errors.ts
+var BimpeAIError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var UserError = class extends BimpeAIError {
+};
+var ConnectionError = class extends BimpeAIError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+};
+var ConnectionTimeoutError = class extends ConnectionError {
+};
+var ApiError = class extends BimpeAIError {
+  status;
+  code;
+  requestId;
+  headers;
+  body;
+  constructor(init) {
+    super(init.message);
+    this.status = init.status;
+    this.code = init.code;
+    this.requestId = init.requestId;
+    this.headers = init.headers;
+    this.body = init.body;
+  }
+};
+var BadRequestError = class extends ApiError {
+};
+var ValidationError = class extends BadRequestError {
+  fieldErrors;
+  constructor(init) {
+    super(init);
+    this.fieldErrors = init.fieldErrors;
+  }
+};
+var AuthenticationError = class extends ApiError {
+};
+var PermissionDeniedError = class extends ApiError {
+};
+var NotFoundError = class extends ApiError {
+};
+var ConflictError = class extends ApiError {
+};
+var RateLimitError = class extends ApiError {
+  retryAfter;
+  limit;
+  remaining;
+  resetAt;
+  constructor(init) {
+    super(init);
+    this.retryAfter = init.retryAfter ?? null;
+    this.limit = init.limit ?? null;
+    this.remaining = init.remaining ?? null;
+    this.resetAt = init.resetAt ?? null;
+  }
+};
+var InternalServerError = class extends ApiError {
+};
+var NotImplementedError = class extends ApiError {
+};
+function mapApiError(status, body, headers) {
+  const errBody = body ?? {};
+  const message = normaliseMessage(errBody.message) ?? `HTTP ${status}`;
+  const code = errBody.code ?? null;
+  const requestId = headers.get("x-request-id") ?? errBody.request_id ?? null;
+  const init = { message, status, code, requestId, headers, body };
+  if (status === 400) {
+    if (code === "validation_error") {
+      return new ValidationError({ ...init, fieldErrors: parseFieldErrors(errBody.message) });
+    }
+    return new BadRequestError(init);
+  }
+  if (status === 401) return new AuthenticationError(init);
+  if (status === 403) return new PermissionDeniedError(init);
+  if (status === 404) return new NotFoundError(init);
+  if (status === 409) return new ConflictError(init);
+  if (status === 429) {
+    return new RateLimitError({
+      ...init,
+      retryAfter: parseRetryAfter(headers.get("retry-after")),
+      limit: numOrNull(headers.get("x-ratelimit-limit")),
+      remaining: numOrNull(headers.get("x-ratelimit-remaining")),
+      resetAt: parseReset(headers.get("x-ratelimit-reset"))
+    });
+  }
+  if (status === 501) return new NotImplementedError(init);
+  if (status >= 500) return new InternalServerError(init);
+  return new ApiError(init);
+}
+function normaliseMessage(m) {
+  if (Array.isArray(m)) return m.join("; ");
+  if (typeof m === "string") return m;
+  return null;
+}
+function parseFieldErrors(m) {
+  if (!Array.isArray(m)) return [];
+  const out = [];
+  for (const entry of m) {
+    if (typeof entry !== "string") continue;
+    const idx = entry.indexOf(":");
+    if (idx === -1) out.push({ path: "", message: entry });
+    else out.push({ path: entry.slice(0, idx).trim(), message: entry.slice(idx + 1).trim() });
+  }
+  return out;
+}
+function parseRetryAfter(raw) {
+  if (!raw) return null;
+  const asNumber = Number(raw);
+  if (Number.isFinite(asNumber)) return Math.max(0, Math.floor(asNumber));
+  const asDate = Date.parse(raw);
+  if (Number.isFinite(asDate)) return Math.max(0, Math.ceil((asDate - Date.now()) / 1e3));
+  return null;
+}
+function parseReset(raw) {
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds)) return null;
+  return new Date(seconds * 1e3);
+}
+function numOrNull(raw) {
+  if (raw === null) return null;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+
+// src/core/headers.ts
+function mergeHeaders(...sources) {
+  const out = new Headers();
+  for (const src of sources) {
+    if (!src) continue;
+    if (src instanceof Headers) {
+      src.forEach((value, key) => out.set(key, value));
+    } else {
+      for (const [key, value] of Object.entries(src)) out.set(key, value);
+    }
+  }
+  return out;
+}
+
+// src/core/request-id.ts
+var HAS_RANDOM_UUID = typeof globalThis.crypto !== "undefined" && typeof globalThis.crypto.randomUUID === "function";
+function generateRequestId() {
+  if (HAS_RANDOM_UUID) return globalThis.crypto.randomUUID();
+  return fallbackUuidV4();
+}
+function fallbackUuidV4() {
+  const bytes = new Uint8Array(16);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+
+// src/core/idempotency.ts
+function resolveIdempotencyKey({
+  supplied,
+  maxRetries
+}) {
+  if (supplied) return supplied;
+  if (maxRetries > 0) return generateRequestId();
+  return null;
+}
+
+// src/core/retries.ts
+var DEFAULT_BASE_MS = 500;
+var DEFAULT_MAX_BACKOFF_MS = 8e3;
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([408, 429]);
+function shouldRetry(error, attempt, maxRetries) {
+  if (attempt >= maxRetries) return false;
+  if (!(error instanceof BimpeAIError)) return false;
+  if (error instanceof ConnectionTimeoutError || error instanceof ConnectionError) return true;
+  if (error instanceof NotImplementedError) return false;
+  if (error instanceof ConflictError) return false;
+  if (error instanceof ApiError) {
+    if (RETRYABLE_STATUSES.has(error.status)) return true;
+    if (error.status >= 500 && error.status !== 501) return true;
+  }
+  return false;
+}
+function computeBackoff(attempt, baseMs = DEFAULT_BASE_MS, maxMs = DEFAULT_MAX_BACKOFF_MS, retryAfterMs) {
+  if (typeof retryAfterMs === "number" && retryAfterMs >= 0) {
+    return Math.min(retryAfterMs, maxMs);
+  }
+  const exponential = Math.min(maxMs, baseMs * 2 ** attempt);
+  const jitter = 0.5 + Math.random() * 0.5;
+  return Math.floor(exponential * jitter);
+}
+
+// src/core/http-client.ts
+var DEFAULT_BASE_URL = "https://api.bimpeai.com";
+var API_PATH_PREFIX = "/api/v1/console";
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  fetchImpl;
+  defaultHeaders;
+  logger;
+  userAgent;
+  constructor(config) {
+    if (!config.apiKey) throw new UserError("apiKey is required");
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = config.timeout ?? 3e4;
+    this.maxRetries = config.maxRetries ?? 2;
+    this.fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.defaultHeaders = config.defaultHeaders ?? {};
+    this.logger = config.logger;
+    this.userAgent = buildUserAgent();
+  }
+  async request(spec) {
+    const url = this.buildUrl(spec.path, spec.query);
+    const maxRetries = spec.maxRetries ?? this.maxRetries;
+    const timeout = spec.timeout ?? this.timeout;
+    const idempotencyKey = isWrite(spec.method) ? resolveIdempotencyKey({ supplied: spec.idempotencyKey, maxRetries }) : null;
+    const requestId = readHeader(spec.headers, "x-request-id") ?? generateRequestId();
+    let attempt = 0;
+    while (true) {
+      try {
+        return await this.send(url, spec, idempotencyKey, requestId, timeout);
+      } catch (error) {
+        if (!shouldRetry(error, attempt, maxRetries)) throw error;
+        const retryAfter = error instanceof ApiError ? parseRetryAfterMs(error.headers.get("retry-after")) : void 0;
+        const delay = computeBackoff(attempt, DEFAULT_BASE_MS, DEFAULT_MAX_BACKOFF_MS, retryAfter);
+        this.logger?.debug("retrying request", { attempt, delay, requestId });
+        await sleep(delay);
+        attempt += 1;
+      }
+    }
+  }
+  async send(url, spec, idempotencyKey, requestId, timeout) {
+    const headers = mergeHeaders(
+      this.defaultHeaders,
+      {
+        Authorization: `Bearer ${this.apiKey}`,
+        Accept: "application/json",
+        "User-Agent": this.userAgent,
+        "X-Request-Id": requestId,
+        ...spec.body !== void 0 ? { "Content-Type": "application/json" } : {},
+        ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+      },
+      spec.headers
+    );
+    const controller = new AbortController();
+    const timeoutHandle = setTimeout(
+      () => controller.abort(new DOMException("timeout", "TimeoutError")),
+      timeout
+    );
+    const { signal, cleanup } = composeSignals(controller.signal, spec.signal);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method: spec.method,
+        headers,
+        body: spec.body !== void 0 ? JSON.stringify(spec.body) : null,
+        signal
+      });
+    } catch (cause) {
+      if (isAbortError(cause)) {
+        if (controller.signal.aborted) throw new ConnectionTimeoutError("request timed out", cause);
+        throw new ConnectionError("request aborted", cause);
+      }
+      throw new ConnectionError("network error", cause);
+    } finally {
+      clearTimeout(timeoutHandle);
+      cleanup();
+    }
+    const text = await response.text();
+    const parsed = text.length ? safeJson(text) : null;
+    if (!response.ok) {
+      throw mapApiError(response.status, parsed, response.headers);
+    }
+    let unwrapped;
+    try {
+      unwrapped = unwrapEnvelope(parsed);
+    } catch {
+      throw new BimpeAIError(
+        `Expected a BimpeAI response envelope but got an unrecognised body (status ${response.status})`
+      );
+    }
+    return {
+      data: unwrapped.data,
+      meta: unwrapped.meta,
+      requestId: response.headers.get("x-request-id") ?? requestId,
+      status: response.status,
+      headers: response.headers
+    };
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseUrl}${API_PATH_PREFIX}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+};
+function buildUserAgent() {
+  const runtime = detectRuntime();
+  const platform = typeof process !== "undefined" ? `${process.platform}/${process.arch}` : "unknown";
+  return `bimpeai-sdk-typescript/${VERSION} (${runtime}; ${platform})`;
+}
+function detectRuntime() {
+  const g = globalThis;
+  if (typeof g.Bun !== "undefined") return `Bun/${g.Bun.version}`;
+  if (typeof g.Deno !== "undefined") return `Deno/${g.Deno.version.deno}`;
+  if (typeof process !== "undefined" && process.versions?.node)
+    return `Node/${process.versions.node}`;
+  return "Browser";
+}
+function isWrite(method) {
+  return method === "POST" || method === "PATCH" || method === "PUT" || method === "DELETE";
+}
+function readHeader(headers, name) {
+  if (!headers) return void 0;
+  const lower = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lower) return value;
+  }
+  return void 0;
+}
+function isAbortError(e) {
+  return typeof e === "object" && e !== null && "name" in e && (e.name === "AbortError" || e.name === "TimeoutError");
+}
+function composeSignals(a, b) {
+  const noop = () => {
+  };
+  if (!b) return { signal: a, cleanup: noop };
+  const anyFn = AbortSignal.any;
+  if (typeof anyFn === "function") return { signal: anyFn([a, b]), cleanup: noop };
+  const ctrl = new AbortController();
+  const onA = () => ctrl.abort(a.reason);
+  const onB = () => ctrl.abort(b.reason);
+  if (a.aborted) ctrl.abort(a.reason);
+  else a.addEventListener("abort", onA, { once: true });
+  if (b.aborted) ctrl.abort(b.reason);
+  else b.addEventListener("abort", onB, { once: true });
+  const cleanup = () => {
+    a.removeEventListener("abort", onA);
+    b.removeEventListener("abort", onB);
+  };
+  return { signal: ctrl.signal, cleanup };
+}
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function parseRetryAfterMs(raw) {
+  if (!raw || !raw.trim()) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, Math.floor(seconds)) * 1e3;
+  const asDate = Date.parse(raw);
+  if (Number.isFinite(asDate)) return Math.max(0, asDate - Date.now());
+  return void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/agents/actions.ts
+var AgentActions = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list(agentId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/actions`
+    });
+    return res.data;
+  }
+};
+
+// src/core/pagination.ts
+var Page = class {
+  data;
+  meta;
+  requestId;
+  fetcher;
+  constructor(init) {
+    this.data = init.data;
+    this.meta = init.meta;
+    this.requestId = init.requestId;
+    this.fetcher = init.fetcher;
+  }
+  get hasNextPage() {
+    return this.meta?.has_next_page === true;
+  }
+  async getNextPage() {
+    if (!this.hasNextPage || !this.meta) return null;
+    return this.fetcher(this.meta.current_page + 1);
+  }
+  async *[Symbol.asyncIterator]() {
+    let cursor = this;
+    while (cursor) {
+      for (const item of cursor.data) yield item;
+      cursor = await cursor.getNextPage();
+    }
+  }
+  async *pages() {
+    let cursor = this;
+    while (cursor) {
+      yield cursor;
+      cursor = await cursor.getNextPage();
+    }
+  }
+};
+var PagePromise = class {
+  load;
+  constructor(load) {
+    this.load = load;
+  }
+  // biome-ignore lint/suspicious/noThenProperty: this is an intentional thenable so list() can be awaited
+  then(onfulfilled, onrejected) {
+    return this.load().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.load().then(void 0, onrejected);
+  }
+  finally(onfinally) {
+    return this.load().finally(onfinally);
+  }
+  async *[Symbol.asyncIterator]() {
+    const first = await this.load();
+    yield* first;
+  }
+  pages() {
+    const load = this.load;
+    return {
+      async *[Symbol.asyncIterator]() {
+        const first = await load();
+        yield* first.pages();
+      }
+    };
+  }
+};
+
+// src/resources/agents/channels.ts
+var AgentChannels = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list(agentId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/channels`
+    });
+    return res.data;
+  }
+};
+
+// src/resources/agents/conversation-flows.ts
+var AgentConversationFlows = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list(agentId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/conversation_flows`
+    });
+    return res.data;
+  }
+};
+
+// src/resources/agents/integrations.ts
+var AgentIntegrations = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list(agentId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/integrations`
+    });
+    return res.data;
+  }
+};
+
+// src/resources/agents/knowledge-bases.ts
+var AgentKnowledgeBases = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list(agentId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/knowledge_bases`
+    });
+    return res.data;
+  }
+  async create(agentId, body, options = {}) {
+    const res = await this.client.request({
+      method: "POST",
+      path: `/agents/${agentId}/knowledge_bases`,
+      body,
+      ...options
+    });
+    return res.data;
+  }
+  async update(agentId, kbId, body) {
+    const res = await this.client.request({
+      method: "PATCH",
+      path: `/agents/${agentId}/knowledge_bases/${kbId}`,
+      body
+    });
+    return res.data;
+  }
+  async delete(agentId, kbId) {
+    await this.client.request({
+      method: "DELETE",
+      path: `/agents/${agentId}/knowledge_bases/${kbId}`
+    });
+  }
+};
+
+// src/resources/agents/agents.ts
+var Agents = class {
+  constructor(client) {
+    this.client = client;
+    this.integrations = new AgentIntegrations(client);
+    this.channels = new AgentChannels(client);
+    this.conversationFlows = new AgentConversationFlows(client);
+    this.actions = new AgentActions(client);
+    this.knowledgeBases = new AgentKnowledgeBases(client);
+  }
+  client;
+  integrations;
+  channels;
+  conversationFlows;
+  actions;
+  knowledgeBases;
+  list(query = {}) {
+    return new PagePromise(() => this.fetchPage(query.page ?? 1, query));
+  }
+  async create(body, options = {}) {
+    const res = await this.client.request({
+      method: "POST",
+      path: "/agents",
+      body,
+      ...options
+    });
+    return res.data;
+  }
+  async retrieve(agentId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}`
+    });
+    return res.data;
+  }
+  async update(agentId, body) {
+    const res = await this.client.request({
+      method: "PATCH",
+      path: `/agents/${agentId}`,
+      body
+    });
+    return res.data;
+  }
+  async fetchPage(page, query) {
+    const res = await this.client.request({
+      method: "GET",
+      path: "/agents",
+      query: { page, limit: query.limit, search: query.search, sort: query.sort }
+    });
+    return new Page({
+      data: res.data,
+      meta: res.meta,
+      requestId: res.requestId,
+      fetcher: (next) => this.fetchPage(next, query)
+    });
+  }
+};
+
+// src/resources/calls/calls.ts
+var Calls = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async list() {
+    const res = await this.client.request({ method: "GET", path: "/calls" });
+    return res.data;
+  }
+};
+
+// src/resources/conversations/messages.ts
+var Messages = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(agentId, conversationId, query = {}) {
+    return new PagePromise(() => this.fetchPage(agentId, conversationId, query.page ?? 1, query));
+  }
+  async send(agentId, conversationId, body, options = {}) {
+    const res = await this.client.request({
+      method: "POST",
+      path: `/agents/${agentId}/conversations/${conversationId}/messages`,
+      body,
+      ...options
+    });
+    return res.data;
+  }
+  async fetchPage(agentId, conversationId, page, query) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/conversations/${conversationId}/messages`,
+      query: { page, limit: query.limit }
+    });
+    return new Page({
+      data: res.data,
+      meta: res.meta,
+      requestId: res.requestId,
+      fetcher: (next) => this.fetchPage(agentId, conversationId, next, query)
+    });
+  }
+};
+
+// src/resources/conversations/conversations.ts
+var Conversations = class {
+  constructor(client) {
+    this.client = client;
+    this.messages = new Messages(client);
+  }
+  client;
+  messages;
+  list(agentId, query = {}) {
+    return new PagePromise(() => this.fetchPage(agentId, query.page ?? 1, query));
+  }
+  async retrieve(agentId, conversationId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/conversations/${conversationId}`
+    });
+    return res.data;
+  }
+  async fetchPage(agentId, page, query) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/agents/${agentId}/conversations`,
+      query: { page, limit: query.limit, search: query.search, channel: query.channel }
+    });
+    return new Page({
+      data: res.data,
+      meta: res.meta,
+      requestId: res.requestId,
+      fetcher: (next) => this.fetchPage(agentId, next, query)
+    });
+  }
+};
+
+// src/resources/workflows/workflows.ts
+var Workflows = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(query = {}) {
+    return new PagePromise(() => this.fetchPage(query.page ?? 1, query));
+  }
+  async create(body, options = {}) {
+    const res = await this.client.request({
+      method: "POST",
+      path: "/workflows",
+      body,
+      ...options
+    });
+    return res.data;
+  }
+  async retrieve(workflowId) {
+    const res = await this.client.request({
+      method: "GET",
+      path: `/workflows/${workflowId}`
+    });
+    return res.data;
+  }
+  async update(workflowId, body) {
+    const res = await this.client.request({
+      method: "PATCH",
+      path: `/workflows/${workflowId}`,
+      body
+    });
+    return res.data;
+  }
+  async delete(workflowId) {
+    await this.client.request({
+      method: "DELETE",
+      path: `/workflows/${workflowId}`
+    });
+  }
+  async fetchPage(page, query) {
+    const res = await this.client.request({
+      method: "GET",
+      path: "/workflows",
+      query: {
+        page,
+        limit: query.limit,
+        search: query.search,
+        sort: query.sort,
+        scope: query.scope
+      }
+    });
+    return new Page({
+      data: res.data,
+      meta: res.meta,
+      requestId: res.requestId,
+      fetcher: (next) => this.fetchPage(next, query)
+    });
+  }
+};
+
+// src/client.ts
+var BimpeAI = class {
+  agents;
+  workflows;
+  conversations;
+  calls;
+  http;
+  constructor(config) {
+    this.http = new HttpClient(config);
+    this.agents = new Agents(this.http);
+    this.workflows = new Workflows(this.http);
+    this.conversations = new Conversations(this.http);
+    this.calls = new Calls(this.http);
+  }
+  request(spec) {
+    return this.http.request(spec);
+  }
+};
+
+exports.AgentActions = AgentActions;
+exports.AgentChannels = AgentChannels;
+exports.AgentConversationFlows = AgentConversationFlows;
+exports.AgentIntegrations = AgentIntegrations;
+exports.AgentKnowledgeBases = AgentKnowledgeBases;
+exports.Agents = Agents;
+exports.ApiError = ApiError;
+exports.AuthenticationError = AuthenticationError;
+exports.BadRequestError = BadRequestError;
+exports.BimpeAI = BimpeAI;
+exports.BimpeAIError = BimpeAIError;
+exports.Calls = Calls;
+exports.ConflictError = ConflictError;
+exports.ConnectionError = ConnectionError;
+exports.ConnectionTimeoutError = ConnectionTimeoutError;
+exports.Conversations = Conversations;
+exports.InternalServerError = InternalServerError;
+exports.Messages = Messages;
+exports.NotFoundError = NotFoundError;
+exports.NotImplementedError = NotImplementedError;
+exports.Page = Page;
+exports.PagePromise = PagePromise;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.RateLimitError = RateLimitError;
+exports.UserError = UserError;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.Workflows = Workflows;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map